Quantum Computing With Cirq

Author: Joydeb Gan Prokas

Table of Contents

Part 1: Basic Concepts and Foundations

• 1.0 Representing Qubits
• 1.1 Quantum Circuit
• 1.2 Quantum Gates(X H Z)
• 1.3 Entanglement
• 1.4 Noise And Fidelity
• 1.5 Noise In Ghz State
• 1.6 Error Correction

Part 2: Advanced Protocols and Algorithms

• 2.1 Bb84 Protocol
• 2.2 Eve Attakacks Bb84 Protocol
• 2.3 Quantum Teleportation Protocol
• 2.4 Superdense Coding Protocol
• 2.5 Quantum Network
• 2.6 Variational Algorithm(Minimize Cost)
• 2.7 Grovers Algorithm

1.0 Representing Qubits

Representing Different Qubit States

1. Creating Two-Dimensional Vectors for |0⟩ and |1⟩ States

In quantum computing, the basis states $|0\rangle$ and $|1\rangle$ are represented as two-dimensional vectors. These vectors can be written in Dirac notation as follows:

• $$ |0\rangle = \begin{pmatrix} 1 \\ 0 \end{pmatrix} $$
• $$ |1\rangle = \begin{pmatrix} 0 \\ 1 \end{pmatrix} $$

# Vector representing the |0⟩ state
zero_state = [1, 0]

# Vector representing the |1⟩ state
one_state = [0, 1]

2. Representing the Vector to Dirac Notation

In quantum computing, vectors can be converted to Dirac notation. Using Cirq, we can represent quantum states and convert them accordingly.

As an example, cirq.dirac_notation(zero_state) converts the zero_state vector to Dirac notation:

import cirq

print(cirq.dirac_notation(zero_state))
print(cirq.dirac_notation(one_state))

|0⟩
|1⟩

3.Bloch Sphere Representation

We can visualize a quantum state on a Bloch sphere using Cirq Web, we can use the BlochSphere class from cirq_web. Here's how to display it in a Jupyter notebook:

from cirq_web import BlochSphere

bloch_sphere_at_zero_state = BlochSphere(state_vector=zero_state, sphere_radius=4)
bloch_sphere_at_one_state = BlochSphere(state_vector=one_state, sphere_radius=4)

print("BlochSphere representing 0 state: ")
display(bloch_sphere_at_zero_state)
print("BlochSphere representing 1 state: ")
display(bloch_sphere_at_one_state)

BlochSphere representing 0 state: 

BlochSphere representing 1 state: 

Creating Superposition States

In quantum computing, a superposition state is a combination of basis states with specific coefficients.

Here, we'll create the superposition states $$ |+\rangle = \frac{1}{\sqrt{2}}(|0\rangle + |1\rangle) $$ and $$ |-\rangle = \frac{1}{\sqrt{2}}(|0\rangle - |1\rangle) $$

1. Creating $|+\rangle$ state and Representing it :

import numpy as np

plus_sate = [1/np.sqrt(2), 1/np.sqrt(2)]

print("Representing Plus State in Dirac notation: ")
display(cirq.dirac_notation(plus_sate))

bloch_sphere_at_plus_state = BlochSphere(state_vector=plus_sate, sphere_radius=4)
print("\n\nBlochSphere representing + state: ")
display(bloch_sphere_at_plus_state)

Representing Plus State in Dirac notation: 

'0.71|0⟩ + 0.71|1⟩'

BlochSphere representing + state: 

2. Creating $|-\rangle$ state and Representing it :

minus_sate = [1/np.sqrt(2), -1/np.sqrt(2)]

print("Representing minus State in Dirac notation: ")
display(cirq.dirac_notation(minus_sate))

bloch_sphere_at_minus_state = BlochSphere(state_vector=minus_sate, sphere_radius=4)
print("\n\nBlochSphere representing - state: ")
display(bloch_sphere_at_minus_state)

Representing minus State in Dirac notation: 

'0.71|0⟩ - 0.71|1⟩'

BlochSphere representing - state: 

Practice Question

• Create a vector that has a $\frac{1}{3}$ chance of being measured in the $|0\rangle$ state and $\frac{2}{3}$ chance of being measured in the $|1\rangle$ state.
• Represent the state using ket notation and describe its representation on the Bloch sphere.

# Solve ->

random_state = [1/np.sqrt(3), np.sqrt(2)/np.sqrt(3)]

print("Representing the State in Dirac notation: ")
display(cirq.dirac_notation(random_state))

bloch_sphere_at_random_state = BlochSphere(state_vector=random_state, sphere_radius=4)
print("\n\nBlochSphere representing Random state: ")
display(bloch_sphere_at_random_state)

Representing the State in Dirac notation: 

'0.58|0⟩ + 0.82|1⟩'

BlochSphere representing Random state: 

The components of the state vector $[\frac{1}{\sqrt{3}}, \frac{\sqrt{2}}{\sqrt{3}}]$ can be squared to understand the probability distribution of the quantum state:

• The probability of measuring the qubit in the state $|0\rangle$ is $\left(\frac{1}{\sqrt{3}}\right)^2 = \frac{1}{3}$.

• The probability of measuring the qubit in the state $|1\rangle$ is $\left(\frac{\sqrt{2}}{\sqrt{3}}\right)^2 = \frac{2}{3}$.

This illustrates a probabilistic quantum state where measurements will yield the $|0\rangle$ state with a probability of $\frac{1}{3}$ and the $|1\rangle$ state with a probability of $\frac{2}{3}$.

1.1 Quantum Circuit

Getting Started With Quantum Circuits

Step 1: Creating a Qubit

Using the cirq.NamedQubit() method to create and define a qubit with a specific name.

import cirq

my_qubit = cirq.NamedQubit('q0')

Step 2: Creating a Quantum Circuit

Using the cirq.Circuit() method to create an empty circuit.

my_circuit = cirq.Circuit() 

Step 3: Modifying a Circuit

Right now we have an empty circuit. To modify our circuit, we need to add objects to the circuit. To modify the circuit, we use the append() method.

my_circuit.append(cirq.measure(my_qubit))
my_circuit

q0: ───M───

Note: cirq.measure(my_qubit): This line appends a measurement operation to my_circuit. The measure function from Cirq is used to create a measurement gate that measures the state of my_qubit.

Step 4: Simulating a Circuit

At the end of the circuit, we want to simulate the result of running the circuit.

To simulate the circuit and obtain results, you can use the following steps:

1. Initialize a Simulator: Use cirq.Simulator() to create a quantum circuit simulator.

2. Run the Circuit: Use the simulator's run method to execute the circuit and obtain measurement results.

sim = cirq.Simulator()
result = sim.run(my_circuit)
result

q0=0

Fact : We can simulate as much time we want by passing value for repetition number

• For example if we want to run 10 times we can use results = sim.run(my_circuit, repetitions=10)

results = sim.run(my_circuit, repetitions=10)
results

q0=0000000000

Practice Question

• Create a list of five qubits.
• Create a quantum circuit and append a measurement for each of your qubits.
• Simulate the result of your circuit.

# Solve ->

my_qubits = [cirq.NamedQubit('q0'), cirq.NamedQubit('q1'), cirq.NamedQubit('q2'), cirq.NamedQubit('q3'), cirq.NamedQubit('q4')]
my_circuit = cirq.Circuit()

my_circuit.append(cirq.measure(my_qubits[0]))
my_circuit.append(cirq.measure(my_qubits[1]))
my_circuit.append(cirq.measure(my_qubits[2]))
my_circuit.append(cirq.measure(my_qubits[3]))
my_circuit.append(cirq.measure(my_qubits[4]))

display(my_circuit)

#since we have to measure all we can simply write 
#my_circuit.append(cirq.measure(my_qubits))

my_simulator = cirq.Simulator()
results = my_simulator.run(my_circuit)

results

q0: ───M───

q1: ───M───

q2: ───M───

q3: ───M───

q4: ───M───

q0=0
q1=0
q2=0
q3=0
q4=0

Alternative: Creating Multiple Qubits Using range() Method

We can create multiple qubits using the range() method. This method allows us to efficiently generate a list of qubits.

my_qubits = cirq.NamedQubit.range(5, prefix= 'q')

my_circuit = cirq.Circuit()

my_circuit.append(cirq.measure(my_qubits))

display(my_circuit)

my_simulator = cirq.Simulator()
results = my_simulator.run(my_circuit)

results

q0: ───M───
       │
q1: ───M───
       │
q2: ───M───
       │
q3: ───M───
       │
q4: ───M───

q0,q1,q2,q3,q4=0, 0, 0, 0, 0

Explanation:

cirq.NamedQubit.range(5, prefix='q'): This method creates a list of 5 named qubits.

• The 5 indicates the number of qubits to create.
• The prefix='q' specifies that each qubit should have a name starting with 'q'.
• The resulting qubits will be named 'q0', 'q1', 'q2', 'q3', and 'q4'.

1.2 Quantum Gates(X H Z)

Single Qubit Quantum Gates (X, H, Z)

import cirq

1. Pauli-X Gate (X)

The matrix representation of the Pauli-X gate is:

$$ X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix} $$

Operation: The Pauli-X gate is analogous to the classical NOT gate.

• It flips the state of a qubit from $|0\rangle$ to $|1\rangle$ and vice versa.

$$ X|0\rangle \rightarrow |1\rangle $$

$$ X|1\rangle \rightarrow |0\rangle $$

• For the $|+\rangle$ and $|-\rangle$ states:

$$ X|+\rangle \rightarrow |+\rangle $$

$$ X|-\rangle \rightarrow -|-\rangle $$

1.1 Creating Pauli-X Gate and Applying

• The cirq.X() gate in Cirq represents the Pauli-X gate, which is fundamental in quantum computing for performing bit-flip operations.

from cirq.contrib.svg import SVGCircuit

qubit = cirq.NamedQubit('q0')
qc = cirq.Circuit()

qc.append(cirq.X(qubit))

# Print the circuit for reference
print("Circuit:")
print(qc)

# Display the circuit using SVGCircuit for better visualization
display(SVGCircuit(qc))

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Circuit:
q0: ───X───

Note: SVGCircuit from cirq.contrib.svg

The SVGCircuit class allows visualizing quantum circuits as Scalable Vector Graphics (SVG) images in Jupyter notebooks.

Warning ? : The warning message findfont: Font family 'Arial' not found. typically appears when Matplotlib cannot find the specified font family for rendering text in plots or diagrams. This issue is common in some environments but usually does not affect the functionality of SVGCircuit from cirq.contrib.svg.

1.2 After Operation

from cirq_web import BlochSphere

stateVector = cirq.final_state_vector(qc)
ket = cirq.dirac_notation(stateVector)
bloch_sphere = BlochSphere(state_vector = stateVector)

print('State Vector: ')
print(stateVector)
print('\n\nDirac Notation: ')
print(ket)
print('\n\nBloch Sphere: ')
display(bloch_sphere)

State Vector: 
[0.+0.j 1.+0.j]


Dirac Notation: 
|1⟩


Bloch Sphere: 

Conclusion: Initially, the qubit (q0) was in the $|0\rangle$ state by default. After applying the X-Gate, it transitions to the $|1\rangle$ state. This transformation demonstrates the effect of the X-Gate, which flips the qubit's state.

2. Hadamard Gate (H)

The matrix representation of the Hadamard gate is:

$$ H = \frac{1}{\sqrt{2}} \begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix} $$

Operation: The Hadamard gate creates a superposition state from a basis state.

• It maps the basis states $|0\rangle$ and $|1\rangle$ to an equal superposition of both states.

$$ H|0\rangle \rightarrow \frac{1}{\sqrt{2}} (|0\rangle + |1\rangle) \text{ or } |+\rangle $$

$$ H|1\rangle \rightarrow \frac{1}{\sqrt{2}} (|0\rangle - |1\rangle) \text{ or } |-\rangle $$

• For the $|+\rangle$ and $|-\rangle$ states:

$$ H|+\rangle \rightarrow |0\rangle $$

$$ H|-\rangle \rightarrow |1\rangle $$

2.1 Creating Pauli-X Gate and Applying

• The cirq.H() gate in Cirq represents the Pauli-X gate, which is fundamental in quantum computing for performing bit-flip operations.

qubit = cirq.NamedQubit('q0')
qc = cirq.Circuit()

qc.append(cirq.H(qubit))


print("Circuit:")
print(qc)

display(SVGCircuit(qc))

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Circuit:
q0: ───H───

2.2 After Operation

stateVector = cirq.final_state_vector(qc)
ket = cirq.dirac_notation(stateVector)
bloch_sphere = BlochSphere(state_vector = stateVector)


print('State Vector: ')
print(stateVector)
print('\n\nDirac Notation: ')
print(ket)
print('\n\nBloch Sphere: ')
display(bloch_sphere)

State Vector: 
[0.70710677+0.j 0.70710677+0.j]


Dirac Notation: 
0.71|0⟩ + 0.71|1⟩


Bloch Sphere: 

Conclusion: Initially, the qubit (q0) was in the $|0\rangle$ state by default. After applying the Hadamard gate (H), it transitions to the $|+\rangle$ state. This transformation demonstrates the effect of the Hadamard gate, which creates a superposition state by equally weighting the $|0\rangle$ and $|1\rangle$ states.

3. Pauli-Z Gate (Z)

The matrix representation of the Pauli-Z gate is:

$$ Z = \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix} $$

Operation: The Pauli-Z gate leaves the basis state $|0\rangle$ unchanged and flips the sign of the basis state $|1\rangle$.

• For the $|0\rangle$ and $|1\rangle$ states: $$ Z|0\rangle \rightarrow |0\rangle $$

$$ Z|1\rangle \rightarrow -|1\rangle $$

• For the $|+\rangle$ and $|-\rangle$ states:

$$ Z|+\rangle \rightarrow |-\rangle $$

$$ Z|-\rangle \rightarrow |+\rangle $$

3.1 Creating Pauli-Z Gate and Applying

• We will apply the Z-gate on the $|+\rangle$ state.
• First, we will transform the $|0\rangle$ state into the $|+\rangle$ state using the Hadamard (H) gate and then apply the Z-Gate.
• The cirq.Z() gate in Cirq represents the Pauli-Z gate, which is fundamental in quantum computing for performing phase-flip operations.

qubit = cirq.NamedQubit('q0')
qc = cirq.Circuit()


qc.append(cirq.H(qubit))
qc.append(cirq.Z(qubit))

# Print the circuit for reference
print("Circuit:")
print(qc)

# Display the circuit using SVGCircuit for better visualization
display(SVGCircuit(qc))

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Circuit:
q0: ───H───Z───

3.2 After Operation

stateVector = cirq.final_state_vector(qc)
ket = cirq.dirac_notation(stateVector)
bloch_sphere = BlochSphere(state_vector = stateVector)


print('State Vector: ')
print(stateVector)
print('\n\nDirac Notation: ')
print(ket)
print('\n\nBloch Sphere: ')
display(bloch_sphere)

State Vector: 
[ 0.70710677+0.j -0.70710677+0.j]


Dirac Notation: 
0.71|0⟩ - 0.71|1⟩


Bloch Sphere: 

Conclusion: Initially, the qubit (q0) was in the $|+\rangle$ state after applying the Hadamard gate (H). Upon applying the Pauli-Z gate (Z), the $|+\rangle$ state transitions to the $|-\rangle$ state. This transformation demonstrates the effect of the Pauli-Z gate, which flips the phase of the qubit's superposition state.

Practice Question

• Create a qubit with label 'q0'.
• Create an empty quantum circuit (qc).
• Append a Pauli-Hadamard (H) gate to the qubit in qc.
• Apply a Pauli-X (X) gate to the qubit in qc.
• Apply a Pauli-Z (Z) gate to the qubit in qc.
• Apply another Pauli-Hadamard (H) gate to the qubit in qc.
• Print out the quantum circuit qc.
• Print out the State Vector, Dirac notation and Bloch Sphere representation of the qubit in qc.

# Solve ->

qubit = cirq.NamedQubit('q0')
qc = cirq.Circuit()


qc.append(cirq.H(qubit))
qc.append(cirq.X(qubit))
qc.append(cirq.Z(qubit))
qc.append(cirq.H(qubit))

# Print the circuit for reference
print("Circuit:")
print(qc)



stateVector = cirq.final_state_vector(qc)
ket = cirq.dirac_notation(stateVector)
bloch_sphere = BlochSphere(state_vector = stateVector)


print('\n\nState Vector: ')
print(stateVector)
print('\n\nDirac Notation: ')
print(ket)
print('\n\nBloch Sphere: ')
display(bloch_sphere)

Circuit:
q0: ───H───X───Z───H───


State Vector: 
[0.        +0.j 0.99999994+0.j]


Dirac Notation: 
|1⟩


Bloch Sphere: 

Conclusion:

• Initially, the qubit (q0) was prepared in the $|0\rangle$ state.
• After applying a Hadamard (H) gate, the qubit transitions to the $|+\rangle$ state.
• Applying an X gate (Pauli-X) leaves the qubit unchanged from $|+\rangle$.
• Applying a Z gate (Pauli-Z) flips the phase of the qubit to the $|-\rangle$ state.
• Applying another Hadamard (H) gate transforms the qubit to the $|1\rangle$ state in the final state.

1.3 Entanglement

Entanglement

• Entanglement is a quantum phenomenon where the state of two or more particles becomes interconnected such that the state of each particle cannot be described independently of the state of the others, even when the particles are separated by large distances.

• Entangled qubits are connected in such a way that the measurement of one qubit instantly determines the state of the other qubit, regardless of the distance between them. This connection results in strong correlations between the states of the entangled qubits, which are not possible in classical systems.

Creating Entanglement with Hadamard and CNOT Gates

To create an entangled state between two qubits, we can use a combination of the Hadamard (H) gate and the Controlled-NOT (CNOT) gate. Let's denote two qubits as $|q_0\rangle$ and $|q_1\rangle$.

1. Apply the Hadamard (H) gate to the first qubit ($|q_0\rangle$): $$ H|q_0\rangle = \frac{1}{\sqrt{2}}(|0\rangle + |1\rangle) $$

   After applying the H gate, the state of $|q_0\rangle$ is now a superposition of $|0\rangle$ and $|1\rangle$.

2. Apply the Controlled-NOT (CNOT) gate with $|q_0\rangle$ as the control qubit and $|q1\rangle$ as the target qubit:

   • If $|q_0\rangle$ = $|0\rangle$ , $|q_1\rangle$ remains unchanged.
   • If $|q_0\rangle$ = $|1\rangle$ , $|q_1\rangle$ is flipped.

   This operation results in the following entangled state: $$ \text{CNOT}(H|q_0\rangle \otimes |q_1\rangle) = \frac{1}{\sqrt{2}}(|00\rangle + |11\rangle) $$

   Here, $|00\rangle$ and $|00\rangle$ are two possible Bell states, specifically $ |\Phi^+\rangle $ , which are entangled states where both qubits are in the same state.

What is a Controlled-NOT (CNOT) Gate ??

Matrix Representation:

The CNOT gate's action can be represented by the following matrix: $$ \text{CNOT} = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{pmatrix} $$

Where the rows and columns correspond to the basis states $|00\rangle$, $|01\rangle$, $|10\rangle$, $|11\rangle$ respectively.

Operation:

• $\text{CNOT}$ gate flips the state of the target qubit (second qubit) if and only if the control qubit (first qubit) is in the state $|1\rangle$.

Case 1: If the control qubit is $|1\rangle$, the target qubit is flipped.

• CX $|1\rangle \rightarrow |0\rangle$
• CX $|0\rangle \rightarrow |1\rangle$

Case 2: If the control qubit is $|0\rangle$, the target qubit remains unchanged.

• CX $|1\rangle \rightarrow |1\rangle$
• CX $|0\rangle \rightarrow |0\rangle$

How to apply a CNOT-Gate ??

import cirq
from cirq.contrib.svg import SVGCircuit

my_qubits = cirq.NamedQubit.range(2, prefix='q')
qc = cirq.Circuit()

qc.append(cirq.CNOT(my_qubits[0], my_qubits[1]))

display(qc)

display(SVGCircuit(qc))

q0: ───@───
       │
q1: ───X───

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Remember!! : The warning message findfont: Font family 'Arial' not found. typically appears when Matplotlib cannot find the specified font family for rendering text in plots or diagrams. This issue is common in some environments but usually does not affect the functionality of SVGCircuit from cirq.contrib.svg.

Creating an Entanglement State

Now that we know how to create both H-Gate and CNOT-Gate, let's follow the steps to create Entanglement.

Step 1: Create two qubits $q_0$ and $q_1$ and add them to the circuit.

Step 2: Apply the Hadamard gate to the first qubit.

Step 3: Apply the Controlled-NOT (CNOT) gate with $|q_0\rangle$ as the control qubit and $|q_1\rangle$ as the target qubit.

import cirq
from cirq.contrib.svg import SVGCircuit

my_qubits = cirq.NamedQubit.range(2, prefix='q')
qc = cirq.Circuit()

qc.append(cirq.H(my_qubits[0]))
qc.append(cirq.CNOT(my_qubits[0], my_qubits[1]))

display(qc)

display(SVGCircuit(qc))

q0: ───H───@───
           │
q1: ───────X───

findfont: Font family 'Arial' not found.

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Beauty of Entanglement

Now that we have created an Entangled state, we can explore its properties and behaviors:

1. Check the Entangled State

   • Verify the state created by the entanglement process.

2. Add Measurement

   • Apply measurements to observe the quantum states of the entangled qubits.

3. Simulate for Multiple Times and Examine Results

   • Run simulations to observe how measurements of entangled qubits correlate over multiple repetitions, revealing the probabilistic nature of quantum measurements.

4. Visualize the Result using Histogram for Multiple Repetitions

   • To visualize the result using a histogram, we can observe the distribution of measurement outcomes. This helps in understanding the probabilistic nature of quantum measurements and how entangled qubits behave under repeated measurements.

1. Checking the Entangled State :

entangled_state = cirq.final_state_vector(qc)

display(cirq.dirac_notation(entangled_state))

'0.71|00⟩ + 0.71|11⟩'

2. Adding Measurement :

qc.append(cirq.measure(my_qubits))

display(qc)

display(SVGCircuit(qc))

q0: ───H───@───M───
           │   │
q1: ───────X───M───

findfont: Font family 'Arial' not found.

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

3. Simulating for 10 Times and Examining Results :

simulator = cirq.Simulator()

results = simulator.run(qc, repetitions=10)

results

q0,q1=0011010011, 0011010011

Entanglement Measurement Results :

• After creating an entangled state and running measurements on qubits $q_0$ and $q_1$ for 10 repetitions using a quantum simulator, the results show that every time, the state of $q_0$ and $q_1$ is the same:

• These binary strings represent the outcomes of measuring qubits $q_0$ and $q_1$, respectively, over multiple runs of the circuit. Entanglement ensures that the measurement results of entangled qubits exhibit strong correlations, as evidenced by the similarity in outcomes between the two qubits.

4. Visualizing the Result using Histogram for 1000 Repetitions :

import matplotlib.pyplot as plt

results = simulator.run(qc, repetitions=10000)

_ = cirq.plot_state_histogram(results, plt.subplot(), title='Qubit States', xlabel='States', ylabel='Occurrence', tick_label=['00', '01', '10', '11'])
plt.show()

Explanation of Code: Plotting State Histogram in Cirq

The code snippet cirq.plot_state_histogram(results, plt.subplot(), title='Qubit States', xlabel='States', ylabel='Occurrence', tick_label=binary_labels(2)) performs the following actions:

1. Plot State Histogram: It uses cirq.plot_state_histogram function to create a histogram of quantum measurement results.

2. Arguments:

   • results: This variable holds the measurement results obtained from running a quantum circuit simulation.
   • plt.subplot(): Creates a subplot for the histogram using Matplotlib.
   • title='Qubit States': Sets the title of the histogram plot to 'Qubit States'.
   • xlabel='States': Labels the x-axis of the histogram as 'States'.
   • ylabel='Occurrence': Labels the y-axis of the histogram as 'Occurrence'.
   • tick_label=binary_labels(2): Specifies the tick labels for the histogram bins. binary_labels(2) generates binary labels for 2 qubits, representing possible measurement outcomes.

3. Displaying the Plot: The plot is displayed using plt.show(), which renders the histogram in the notebook output.

Practice Question:

• Create two qubits.
• Add an H gate to the first qubit and an X gate to the second qubit, followed by a CNOT gate with the first qubit as the control and the second qubit as the target.
• Measure both qubits at the end.
• Output your circuit.
• Simulate the result of your circuit for 10,000 times and plot a histogram.

# Solve ->

import cirq
import matplotlib.pyplot as plt


my_qubits = cirq.NamedQubit.range(2, prefix='q')          # Creating two named qubits, 'q0' and 'q1'
my_circuit = cirq.Circuit()                               # Creating an empty circuit



my_circuit.append(cirq.H(my_qubits[0]))                   # Apply H gate to q0: puts it in superposition (|+> state)
my_circuit.append(cirq.X(my_qubits[1]))                   # Apply X gate to q1: flips its state to |1>
my_circuit.append(cirq.CNOT(my_qubits[0], my_qubits[1]))  # Apply CNOT with q0 as control and q1 as target: entangles qubits




my_circuit.append(cirq.measure(my_qubits))                 # Measuring both qubits q0 and q1




print("Circuit:\n")                                         # Printing the circuit structure
print(my_circuit)
display(SVGCircuit(qc))



simulator = cirq.Simulator()
results = simulator.run(my_circuit, repetitions=10000)      # Simulating the circuit 10000 times




# Plot a histogram of the measurement results
histogram = cirq.plot_state_histogram(results, plt.subplot(), title='Qubit States', xlabel='States', ylabel='Occurrence', tick_label=['00', '01', '10', '11'])






print("\n\nHistogram:\n")                                     # Displaying the histogram
plt.show()

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Circuit:

q0: ───H───@───M───
           │   │
q1: ───X───X───M───

Histogram:

1.4 Noise And Fidelity

Noise and Fidelity in Quantum Computing

In quantum computing, noise and fidelity are critical concepts that affect the performance and reliability of quantum systems.

Noise

1. Definition:

   • Noise in quantum computing refers to any unwanted interactions or errors that occur in a quantum system, affecting the quantum states or the operations performed on them.

2. Sources of Noise:

   • Decoherence: The process by which quantum information is lost to the environment, causing the system to lose its quantum properties.
   • Gate Errors: Imperfections in the implementation of quantum gates, leading to inaccuracies in quantum operations.
   • Measurement Errors: Inaccuracies in reading the state of a qubit, leading to incorrect results.

3. Impact:

   • Noise can degrade the performance of quantum algorithms by altering the intended quantum states, causing errors in computation, and reducing the overall reliability of the quantum system.

4. Types of Noise:

   • Depolarizing Noise: A type of noise where a qubit's state is replaced with a completely mixed state with a certain probability.
   • Amplitude Damping: A noise process where energy is lost from the quantum system, typically affecting the probability amplitudes.
   • Phase Damping: A noise process that causes dephasing, altering the relative phase between the components of a quantum state.

5. Mitigation:

   • Quantum error correction and noise mitigation techniques are developed to reduce the impact of noise and improve the fidelity of quantum computations.

Fidelity

1. Definition:

   • Fidelity is a measure of how closely a quantum state or operation matches an ideal or reference state or operation. It quantifies the accuracy of quantum operations and the preservation of quantum information.

2. Measurement:

   • Fidelity is typically calculated as the overlap between the ideal quantum state and the actual quantum state produced by a noisy operation.

3. Importance:

   • High fidelity indicates that a quantum system or operation closely approximates the desired outcome, making it reliable for quantum computation.
   • Fidelity is crucial for evaluating the performance of quantum devices and algorithms, as it provides a benchmark for how well they preserve quantum information.

4. Applications:

   • Fidelity is used to assess the effectiveness of quantum gates, circuits, and algorithms.
   • It helps in diagnosing and improving quantum systems by identifying sources of error and optimizing operations to enhance performance.

5. Relation to Noise:

   • Fidelity is inversely related to noise; as noise increases, fidelity typically decreases. Understanding and mitigating noise is essential for improving fidelity in quantum computations.

Importance of Noise Simulation

1. Predicting Performance:

   • Noise simulation allows researchers to predict how quantum circuits will perform under realistic conditions. By understanding potential sources of error, researchers can better design and test quantum algorithms.

2. Developing Error Correction:

   • Simulating noise helps in the development and testing of error correction protocols, which are essential for maintaining the integrity of quantum information in noisy environments.

3. Optimizing Quantum Systems:

   • Noise simulations enable the optimization of quantum systems by allowing researchers to identify weak points in the circuit or system design that are susceptible to noise.

4. Benchmarking and Comparison:

   • Simulations provide a benchmark for comparing different quantum devices and algorithms, helping to determine which configurations are more robust against noise.

5. Advancing Quantum Technology:

   • Understanding the effects of noise through simulation is critical for advancing quantum technology from theoretical models to practical applications, ensuring the development of scalable, reliable quantum computers.

In summary, noise is an inherent challenge in quantum computing that disrupts quantum states, while fidelity serves as a crucial metric for evaluating the accuracy and reliability of quantum operations in the presence of noise. Simulating noise is essential for understanding, mitigating, and ultimately overcoming these challenges to build practical and robust quantum systems.

import random
import matplotlib.pyplot as plt
import numpy as np
import cirq
from cirq.contrib.svg import SVGCircuit

def binary_labels(num_qubits):
    return [bin(x)[2:].zfill(num_qubits) for x in range (2**num_qubits)]

plt.rcParams.update({'font.size': 8})

Part 1: Noisy Simulations

Creating Qubits and Circuit :

qubits = cirq.NamedQubit.range(2, prefix='q')
circuit = cirq.Circuit()

circuit.append(cirq.H(qubits[0]))
circuit.append(cirq.CNOT(qubits[0], qubits[1]))

circuit.append(cirq.measure(qubits))

display(SVGCircuit(circuit))

findfont: Font family 'Arial' not found.

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

1.1: Adding general noises

• Simulating noise by adding it generally to the circuit using .with_noise(...) method

Question 1.1.1 :

• Simulate this circuit with 5% chance of depolarizing noise

noise = cirq.depolarize(0.05)                                       # Defining a noise model 

simulator = cirq.Simulator()                                        # Initializing the Cirq simulator

result = simulator.run(circuit.with_noise(noise), repetitions=100)   # Running the circuit with the noise model


hist = cirq.plot_state_histogram(result, plt.subplot(), title = '5% Depolarization', xlabel='States', ylabel='Occurrences', tick_label=binary_labels(2))

plt.show()

Conclusion After Simulating the Circuit with Noise

After simulating the quantum circuit with a depolarizing noise model, we observe the following:

1. Effect on Superposition and Entanglement:

   • In the absence of noise, the Hadamard and CNOT gates create a superposition and entangled state of the qubits.
   • The 5% depolarizing noise introduces random errors, leading to a mixture of states rather than the pure states expected in an ideal scenario.

2. Impact on Measurement Outcomes:

   • The histogram of measurement outcomes shows increased variability compared to the ideal case.
   • Probabilities for certain quantum states (e.g., $|00\rangle$ or $|11\rangle$) are reduced, while non-zero probabilities appear for states that ideally should not occur.

1.2: Appending Noise to a specific moment

Question 1.2.1:

• Simulate the circuit with a 100% chance of depolarizing noise on just q0 before applying H-Gate

noise = cirq.depolarize(1.0)                                       # Defining a noise model 

# Creating Qubits and circuit

qubits = cirq.NamedQubit.range(2, prefix='q')
circuit = cirq.Circuit()


circuit.append(noise.on_each(qubits[0]))
circuit.append(cirq.H(qubits[0]))
circuit.append(cirq.CNOT(qubits[0], qubits[1]))

circuit.append(cirq.measure(qubits))

display(SVGCircuit(circuit))

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

# Simulating noise 


simulator = cirq.Simulator()                               

result = simulator.run(circuit, repetitions=100)   # Running the circuit with the noise model


hist = cirq.plot_state_histogram(result, plt.subplot(), title = 'Qubit State', xlabel='States', ylabel='Occurrences', tick_label=binary_labels(2))

plt.show()

Impact of 100% Depolarizing Noise Before Hadamard Gate

When applying 100% depolarizing noise to qubit q0 before the Hadamard gate, the state of q0 becomes maximally mixed. This means that:

• Maximally Mixed State: The density matrix of q0 is: $$ \rho = \frac{1}{2} \begin{pmatrix} 1 & 0 \\ 0 & 1 \end{pmatrix} $$ This indicates equal probabilities for measuring |0⟩ or |1⟩.

• Effect of Hadamard Gate: After the depolarizing noise, the Hadamard gate will transform this maximally mixed state into a state resembling |−⟩, which is a specific superposition state: $$ |−⟩ = \frac{1}{\sqrt{2}}(|0⟩ - |1⟩) $$

• Entanglement: Despite the depolarizing noise, the entanglement between q0 and q1 still persists. However, the specific measurement outcomes might shift. For example:

  • The histogram will likely reflect this change in the distribution of measurement results but will still show evidence of entanglement.

Part 2: Noise characterization with Swap Test

2.1: Calculating Fidelity with Swap Test

Question :

1. Prepare 2 qubits in the given states and one ancilla qubit in the $|0\rangle$ state.
2. Append the swap test circuit.
3. Run the circuit.
4. Calculate the fidelity.

2.1.1 : Prepare 2 qubits in the given states and one ancilla qubit in the $|0\rangle$ state.

• put $q_0$ into the $|0\rangle$
• put $q_1$ into the $|1\rangle$
• put ancilla into the $|0\rangle$

q0 = cirq.NamedQubit('state 0')
q1 = cirq.NamedQubit('state 1')
ancilla = cirq.NamedQubit('Ancilla')

#Prepare the qubit states
circuit_0 = cirq.Circuit()
circuit_0.append(cirq.I(q0))
circuit_1 = cirq.Circuit()
circuit_1.append(cirq.X(q1))

circuit = circuit_0 + circuit_1

circuit

state 0: ───I───────

state 1: ───────X───

2.1.2: Append the swap test circuit.

1. Put ancilla in superposition by applying an H gate.
2. Apply controlled-swap gate with ancilla as the controll and other two qubits as the target.
3. Apply an H-Gate on the ancilla.
4. Measure the ancilla qubit.

circuit.append(cirq.H(ancilla))     

circuit.append(cirq.CSWAP(ancilla, q0, q1))

circuit.append(cirq.H(ancilla))

circuit.append(cirq.measure(ancilla))



display(SVGCircuit(circuit))

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

2.1.3: Run the circuit

• Run the circuit 1000 time using a simulator

simulator = cirq.Simulator()

result = simulator.run(circuit, repetitions=1000)

result

Ancilla=0001111101110101110110111111110010001000101000010001111001110000100011000110000111111001011000110111010110111101000111110111001001000110010010110011110111001100010010101100100110111010010101101000101111111101100011100110100101000001011011001110110010010010111101101101110100001101110100101010001000111011100010001001011101011100101011010001000111100110110100011101001010000011110110011001000010010111110001010100111010001000000011011010111000011000100110111110101110100010110101101000000011000010111111100110111001001000110001011111011011011100010011000101110010111001000111011000110011001101000011100010001001100011100010111101100111100010011111101101100010110101111110111101110000001000011101101010110111011011100010101011111101111101000000000011010001100111111100001011110010111010101110100101010110011101001100000001111111000001100100111010010111010110110000000001110110011100000000111111100010101100011010000011111111011101011011001010110100100001000011111111101111010101011001000000110101111010

2.1.4: Calculate the Fidelity

• Calculating fidelity using the equation : Fidelity = 1 - 2 * prob(0)

prob_0 = np.sum(result.measurements['Ancilla'])/len(result.measurements['Ancilla'])

fidelity = 1 - 2*prob_0

fidelity

-0.038000000000000034

2.2: Characterizing Noise with the Swap Test

Question: 2.2.1

• Calculating the fidelity of $q_0$ in our typical Ideal $|0\rangle$ state (meaning there is no noise ) and $q_1$ in a $|0\rangle$ state with 5% chance of depolarization.

# 1.1creating qubits
q0 = cirq.NamedQubit('state 0')
q1 = cirq.NamedQubit('state 1')
ancilla = cirq.NamedQubit('Ancilla')

# 1.2.Prepare the qubit states
circuit_0 = cirq.Circuit()
circuit_0.append(cirq.I(q0))
circuit_1 = cirq.Circuit()
circuit_1.append(cirq.I(q1))


# change made here !!

noise = cirq.depolarize(0.05)
circuit = circuit_0 + circuit_1.with_noise(noise)

# change made upper!!


# 2.Append the swap test circuit.
circuit.append(cirq.H(ancilla))     

circuit.append(cirq.CSWAP(ancilla, q0, q1))

circuit.append(cirq.H(ancilla))

circuit.append(cirq.measure(ancilla))

display(SVGCircuit(circuit))


# 3.Run the circuit
simulator = cirq.Simulator()

result = simulator.run(circuit, repetitions=1000)

print(result)


# 4.Calculate the Fidelity

prob_0 = np.sum(result.measurements['Ancilla'])/len(result.measurements['Ancilla'])

fidelity = 1 - 2*prob_0

findfont: Font family 'Arial' not found.

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Ancilla=0000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000100000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000010000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000100000000000000010000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000100000000000000000010000000000000000000000000000000000000010000000000000000000010000000000000010000000000000000000000000000000100000000000000000000000000000000000

Question: Check Fidelity for 0-100% and visualize

Solve :

depol_probabilities = []

for i in range(21):
    depol_probabilities.append(i*0.05)

depol_probabilities

[0.0,
 0.05,
 0.1,
 0.15000000000000002,
 0.2,
 0.25,
 0.30000000000000004,
 0.35000000000000003,
 0.4,
 0.45,
 0.5,
 0.55,
 0.6000000000000001,
 0.65,
 0.7000000000000001,
 0.75,
 0.8,
 0.8500000000000001,
 0.9,
 0.9500000000000001,
 1.0]

fidelities = []


for prob in depol_probabilities:
    
    # 1.1creating qubits
    q0 = cirq.NamedQubit('state 0')
    q1 = cirq.NamedQubit('state 1')
    ancilla = cirq.NamedQubit('Ancilla')

    # 1.2.Prepare the qubit states
    circuit_0 = cirq.Circuit()
    circuit_0.append(cirq.I(q0))
    circuit_1 = cirq.Circuit()
    circuit_1.append(cirq.I(q1))


    # change made here !!

    noise = cirq.depolarize(prob)
    circuit = circuit_0 + circuit_1.with_noise(noise)

    # change made upper!!


    # 2.Append the swap test circuit.
    circuit.append(cirq.H(ancilla))     

    circuit.append(cirq.CSWAP(ancilla, q0, q1))

    circuit.append(cirq.H(ancilla))

    circuit.append(cirq.measure(ancilla))


    # 3.Run the circuit
    simulator = cirq.Simulator()

    result = simulator.run(circuit, repetitions=1000)


    # 4.Calculate the Fidelity

    prob_0 = np.sum(result.measurements['Ancilla'])/len(result.measurements['Ancilla'])

    fidelity = 1 - 2*prob_0
    
    fidelities.append(fidelity)

fidelities

[1.0,
 0.954,
 0.938,
 0.904,
 0.882,
 0.848,
 0.796,
 0.772,
 0.69,
 0.718,
 0.6779999999999999,
 0.6599999999999999,
 0.61,
 0.53,
 0.476,
 0.536,
 0.508,
 0.43999999999999995,
 0.368,
 0.388,
 0.32599999999999996]

Result Vs Theoretical Prediction :

plt.scatter(depol_probabilities, fidelities, label = 'Simulation')

theoretical_fidelities =  [1 - prob/2 for prob in depol_probabilities]
plt.scatter(depol_probabilities, theoretical_fidelities, label='Theory')

plt.xlabel('Depolarization Probabilities')
plt.ylabel('Fidelities')

plt.legend()
plt.show()

Discussion !!!

In this simulation, we explore the effect of depolarizing noise on the fidelity of a quantum state comparison using a swap test.

Key Components

1. Depolarizing Noise:

   • The code introduces depolarizing noise with varying probabilities (from 0 to 1 in increments of 0.05) to a quantum circuit.
   • Depolarizing noise transforms a qubit's state into a completely mixed state with a certain probability, which can degrade the quality of quantum computations.

2. Swap Test Circuit:

   • The swap test is used to determine the overlap (or fidelity) between two quantum states.
   • It involves using an ancilla qubit and applying Hadamard gates and a controlled swap (CSWAP) operation.

3. Simulation:

   • The circuit is executed multiple times (1000 repetitions) using a simulator to gather statistical results.

4. Fidelity Calculation:

   • The fidelity is calculated as $F = 1 - 2p_0$, where $p_0$ is the probability of measuring the ancilla qubit in the state $|1\rangle$.
   • This gives an indication of how similar the two quantum states are.

5. Plotting:

   • The results are plotted against the theoretical expectation that the fidelity decreases linearly with the depolarizing probability, showing

   • $F = 1 - \frac{\text{prob}}{2}$.

Results Discussion

• Simulation vs. Theory:

  • The scatter plot shows two sets of data points: the simulated fidelities and the theoretical fidelities.
  • Ideally, the simulation results should align closely with the theoretical values.

• Trends:

  • As the depolarization probability increases, the fidelity decreases.
  • This trend is expected because higher depolarization probabilities mean the states become more mixed, reducing their overlap.

• Noise Impact:

  • The results highlight how sensitive quantum states are to noise.
  • Even small amounts of depolarizing noise can significantly reduce the fidelity, which underscores the importance of error correction and mitigation in quantum computing.

• Practical Implications:

  • Understanding the impact of noise is crucial for designing robust quantum algorithms and systems.
  • The simulation provides insights into how real-world noise can affect quantum computations and the importance of accounting for such effects in practical implementations.

Overall, the code effectively demonstrates the relationship between depolarizing noise and fidelity in quantum state comparisons, providing both theoretical and simulated insights.

1.5 Noise In Ghz State

Noise with GHZ state

What is $n$-Qubit GHZ State ?

An ( n )-qubit GHZ (Greenberger-Horne-Zeilinger) state is a type of entangled quantum state that generalizes the concept of Bell states to multiple qubits. It is defined as:

$$ |\text{GHZ}_n\rangle = \frac{1}{\sqrt{2}} \left( |0\rangle^{\otimes n} + |1\rangle^{\otimes n} \right) $$

This state represents an equal superposition of all qubits being in the ∣0⟩ state and all qubits being in the ∣1⟩ state simultaneously.

Example:

For example, the 3-qubit GHZ state is: $$ |\text{GHZ}_3\rangle = \frac{1}{\sqrt{2}} \left( |000\rangle + |111\rangle \right) $$ For a 10-qubit GHZ state, the state vector would be:

$$ |\text{GHZ}_{10}\rangle = \frac{1}{\sqrt{2}} \left( |0000000000\rangle + |1111111111\rangle \right) $$

Create $|\text{GHZ}_3\rangle = \frac{1}{\sqrt{2}} \left( |000\rangle + |111\rangle \right)$ State

import random
import matplotlib.pyplot as plt
import numpy as np
import cirq
from cirq.contrib.svg import SVGCircuit

def binary_labels(num_qubits):
    return [bin(x)[2:].zfill(num_qubits) for x in range (2**num_qubits)]

plt.rcParams.update({'font.size': 8})

Function for creating n-Qubit GHZ state :

def create_n_qubit_ghz_state(n):
    qubits = cirq.NamedQubit.range(n, prefix='q')
    circuit = cirq.Circuit()
    circuit.append(cirq.H(qubits[0]))

    
    for i in range(n-1):
        circuit.append(cirq.CNOT(qubits[i], qubits[i+1]))
    
    circuit.append(cirq.measure(qubits))        # Use only when need to simulate
    
    return circuit

Question 1: Run and simulate the circuit with No noise.

# Create circuit
circuit = create_n_qubit_ghz_state(3)
display(SVGCircuit(circuit))


#print(cirq.dirac_notation(cirq.final_state_vector(circuit))) # Use when there is no measurement and simulate


# Simulate
sim = cirq.Simulator()

result = sim.run(circuit, repetitions=100)

# Plot
hist = cirq.plot_state_histogram(result, plt.subplot(), title='GHZ', xlabel='States', ylabel='Occurrence', tick_label=binary_labels(3))

plt.show()

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Question 1: Run and simulate with 25% chance of Depolarization throughout the whole circuit.

Depolarization :

• Depolarization is a type of noise that causes a quantum state to lose its original information and become a completely mixed state with some probability.

Effect :

• It uniformly randomizes the state of the qubit, effectively "blurring" its state with equal probability of being in any of the possible states.

Impact :

• Depolarization affects all parts of the qubit's state equally and is often used to model errors that have no specific directional bias.

# Create circuit
circuit = create_n_qubit_ghz_state(3)
display(SVGCircuit(circuit))


# Add Noise Model 

noise = cirq.depolarize(0.25)


# Simulate
sim = cirq.Simulator()

result = sim.run(circuit.with_noise(noise), repetitions=100)

# Plot
hist = cirq.plot_state_histogram(result, plt.subplot(), title='25% Depolarization', xlabel='States', ylabel='Occurrence', tick_label=binary_labels(3))

plt.show()

findfont: Font family 'Arial' not found.

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Question 2: Run and simulate with 25% chance of Phase Flipping throughout the whole circuit.

Phase Flipping :

• Phase flipping is a type of error that inverts the phase of a quantum state, flipping the sign of the phase component in the state vector.

Effect

• A phase flip changes the sign of the relative phase between the states $|0\rangle$ and $|1\rangle$. It affects superposition states like $|+\rangle$ and $|-\rangle$.

Impact :

• Phase flips do not change the probabilities of measuring $|0\rangle$ or $|1\rangle$, but they can disrupt quantum algorithms that rely on precise phase relationships, like interference-based algorithms.

# Create circuit
circuit = create_n_qubit_ghz_state(3)
display(SVGCircuit(circuit))


# Add Noise Model 

noise = cirq.phase_flip(0.25)


# Simulate
sim = cirq.Simulator()

result = sim.run(circuit.with_noise(noise), repetitions=100)

# Plot
hist = cirq.plot_state_histogram(result, plt.subplot(), title='25% Phase Flipping', xlabel='States', ylabel='Occurrence', tick_label=binary_labels(3))

plt.show()

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Question 3: Run and simulate with 25% chance of Amplitude Damping throughout the whole circuit.

Amplitude Damping :

• Amplitude damping describes the process where a qubit loses energy, typically due to interaction with its environment, causing it to relax to the $|0\rangle$ state.

Effect :

• This type of noise models phenomena like spontaneous emission, where excited states lose energy and decay to lower energy states.

Impact :

• Amplitude damping reduces the population of excited states, which can lead to loss of information stored in qubits, particularly affecting quantum memory and long-running computations.

# Create circuit
circuit = create_n_qubit_ghz_state(3)
display(SVGCircuit(circuit))


# Add Noise Model 

noise = cirq.amplitude_damp(0.25)


# Simulate
sim = cirq.Simulator()

result = sim.run(circuit.with_noise(noise), repetitions=100)

# Plot
hist = cirq.plot_state_histogram(result, plt.subplot(), title='25% Amplitude Damping', xlabel='States', ylabel='Occurrence', tick_label=binary_labels(3))

plt.show()

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Conclusion

• Depolarization randomizes the state entirely, affecting all components of a qubit’s state.

• Phase Flipping changes the relative phase, impacting interference patterns critical for certain quantum operations.No change in Entangled states.

• Amplitude Damping models energy loss, pushing the system toward lower energy states (0), which can degrade information stored in excited states.

1.6 Error Correction

Error Correction in Quantum Computing

Error correction is a crucial aspect of quantum computing, as it addresses the challenges posed by the fragile nature of quantum states. Quantum bits, or qubits, are highly susceptible to errors due to decoherence and other forms of noise, making reliable computation difficult without correction methods.

Types of Errors

1. Bit Flip Error: Occurs when a qubit changes its state from $|0\rangle$ to $|1\rangle$ or vice versa.
2. Phase Flip Error: Alters the relative phase of a qubit, changing a state like $|+\rangle$ to $|-\rangle$.
3. Amplitude Damping: Describes energy loss, often driving a qubit to the $|0\rangle$ state.

Quantum Error Correction (QEC)

Quantum error correction involves encoding quantum information in a way that allows for the detection and correction of errors without measuring the qubits directly, thus preserving quantum coherence.

Basic Principles

1. Redundancy: Information is distributed across multiple qubits to allow for error detection and correction. For example, in the 3-qubit bit flip code, a single qubit's state is encoded into three qubits.

2. Syndrome Measurement: Detects errors without collapsing the quantum state by measuring auxiliary qubits (ancillas), which indicate the type of error without revealing the encoded information.

3. Error Correction: Based on the syndrome measurement, operations are applied to correct errors and restore the intended quantum state.

Examples of Error Correction Codes

1. Shor Code: Combines bit flip and phase flip correction to protect against arbitrary single-qubit errors using 9 qubits.
2. Steane Code: A 7-qubit code that encodes a single logical qubit and corrects arbitrary single-qubit errors.
3. Surface Codes: Utilize a 2D lattice of qubits and are promising for scalability in practical quantum systems.

Importance of Error Correction

Quantum error correction is essential for the realization of reliable quantum computing. It enables long-duration computations, protects quantum information, and helps achieve fault-tolerant quantum computers, paving the way for practical applications in cryptography, optimization, and more.

By continuously advancing error correction techniques, researchers aim to overcome the limitations imposed by quantum noise and move closer to achieving the full potential of quantum computing.

import random
import matplotlib.pyplot as plt
import numpy as np
import cirq
from cirq.contrib.svg import SVGCircuit

def binary_labels(num_qubits):
    return [bin(x)[2:].zfill(num_qubits) for x in range (2**num_qubits)]

plt.rcParams.update({'font.size': 8})

Part 1: Bit Flip Error

Implementing a 3-Qubit Bit Flip Error Correcting Code Using a 5-Step Process

• Bit flip error correction is a quantum error correction technique designed to protect quantum information from bit flip errors.
• A bit flip error occurs when a qubit's state is erroneously changed from $|0\rangle$ to $|1\rangle$ or from $|1\rangle$ to $|0\rangle$. The 3-qubit bit flip code is a simple yet effective way to detect and correct single bit flip errors.

Process

1. Encoding

• The original qubit state $|\psi\rangle$ is encoded into a three-qubit state.
• For example, if the initial state is $|0\rangle$, it is encoded as $|000\rangle$; if it is $|1\rangle$, it is encoded as $|111\rangle$. This redundancy allows the system to detect errors.

2. Sending Over Noisy Channel

• The encoded qubits are transmitted over a noisy quantum channel. During transmission, one of the qubits may undergo a bit flip error due to noise.

3. Error Detection

• After transmission, the qubits are checked to identify any bit flip errors. This is done by measuring the parity between pairs of qubits. The results indicate whether an error has occurred and which qubit is likely affected.

4. Error Correction

• If a bit flip error is detected, the erroneous qubit is flipped back to its correct state. This step restores the encoded state to its intended form before the error occurred.

5. Decoding

• The corrected three-qubit state is decoded back to the original single-qubit state $|\psi\rangle$. This final step retrieves the intended quantum information, now free of bit flip errors.

Step 1: Encoding

1.1: Initialize a circuit with 3-Qubits and 1 Classical Bit

qubits = cirq.NamedQubit.range(3, prefix='q')
encode_circuit = cirq.Circuit()

1.2: Entangle the state of $q_0$ with other two qubits

encode_circuit.append(cirq.CNOT(qubits[0], qubits[1]))
encode_circuit.append(cirq.CNOT(qubits[0], qubits[2]))

display(SVGCircuit(encode_circuit))

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Step 2: Sending Over Noisy Channel

• Creating a new circuit to represent the noisy channel and specifically simulate a bit flip error on $q_0$.
• Note : X-Gate flips a qubit from $|0\rangle$ to $|1\rangle$ or $|1\rangle$ to $|0\rangle$.

noisy_channel_circuit = cirq.Circuit()

noisy_channel_circuit.append(cirq.X(qubits[0]))

display(SVGCircuit(noisy_channel_circuit))

findfont: Font family 'Arial' not found.

findfont: Font family 'Arial' not found.

Step 3: Error Detection

• Creating a new circuit to detect if there is been an error by checking the parity ( do they agree with each other or different?) of $q_0$ with the other qubits using $CNOT$ gate

detection_circuit = cirq.Circuit()

detection_circuit.append(cirq.CNOT(qubits[0], qubits[2]))
detection_circuit.append(cirq.CNOT(qubits[0], qubits[1]))

display(SVGCircuit(detection_circuit))

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Step 4: Error Correction

• We will now creat a circuit to update $q_0$ if both $q_1$ and $q_2$ have detected a bit flip so that $q_0$ stores the correct logical state.
• Specifically applying the TOFFOLI(CCNOT) gate controlled by $q_2$ and $q_1$, targeting $q_0$.

correction_circuit = cirq.Circuit()

correction_circuit.append(cirq.CCNOT(qubits[2], qubits[1], qubits[0]))

display(SVGCircuit(correction_circuit))

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Step 5: Decoding

• The logical gate has been stored in $q_0$.
• Now creating a decoding circuit to measure this qubit in order to decode the final logical state.

decode_circuit = cirq.Circuit()

decode_circuit.append(cirq.measure(qubits[0]))

display(SVGCircuit(decode_circuit))

findfont: Font family 'Arial' not found.

findfont: Font family 'Arial' not found.

Adding the Circuits and Simulating

• Now that we have created all the part of our bitflip_circuit, we will combine all the circuit together and simulate 100 times to ensure our error correction code really works.

bitflip_circuit = encode_circuit + noisy_channel_circuit + detection_circuit +correction_circuit + decode_circuit

display(SVGCircuit(bitflip_circuit))

sim = cirq.Simulator()

result = sim.run(bitflip_circuit, repetitions=100)

hist = cirq.plot_state_histogram(result, plt.subplot(), title='Bit Flip Error Correction', xlabel='States', ylabel='Occurrence', tick_label=binary_labels(1))

plt.show()

findfont: Font family 'Arial' not found.

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Discussing How the Error is Corrected

This implementation demonstrates how a bit flip error is corrected using a 3-qubit bit flip code. The process involves encoding the original state, introducing an error through a noisy channel, detecting the error, correcting it, and then decoding the state. Here’s how each step works in the circuit:

Steps

1. Encoding

   • The circuit begins by encoding the initial qubit state into three qubits using two CNOT gates. The qubit state is copied onto two additional qubits: $$ \text{CNOT}(q_0, q_1) \quad \text{and} \quad \text{CNOT}(q_0, q_2) $$
   • This creates an entangled state where any bit flip can be detected.

2. Noisy Channel

   • A bit flip error is introduced on the first qubit using an $X$ gate: $$X(q_0)$$
   • This simulates a bit flip error, changing the state of $q_0$ from $|0\rangle$ to $|1\rangle$ or vice versa.

3. Error Detection

   • The circuit detects the error by using additional CNOT gates to check the parity: $$ \text{CNOT}(q_0, q_2) \quad \text{and} \quad \text{CNOT}(q_0, q_1) $$
   • These gates compare the states of the qubits and identify any discrepancies that indicate a bit flip error.

4. Error Correction

   • A Toffoli (CCNOT) gate corrects the detected error: $$ \text{CCNOT}(q_2, q_1, q_0) $$
   • This gate flips the first qubit back to its correct state if an error is detected on the other two qubits.

5. Decoding

   • The final step measures the state of the first qubit to retrieve the corrected state: $$ \text{measure}(q_0) $$
   • This extracts the original quantum information, now corrected for any bit flip errors.

Simulation and Result

• The circuit is simulated using Cirq's Simulator with 100 repetitions. The results are plotted in a histogram, showing the corrected states.
• The histogram displays the frequency of the output states (all in $|0\rangle$ state), indicating successful error correction by showing a high occurrence of the $|0\rangle$ state.

This process showcases the basic principles of quantum error correction, illustrating how redundancy and error detection/correction mechanisms work together to preserve quantum information.

Question 1: Modify the code to prepare the logical qubit in $|1\rangle$ state

# Preparing given state
prepare_circuit = cirq.Circuit()
prepare_circuit.append(cirq.X(qubits[0]))

# Appending Rest of the circuit
bitflip_circuit = prepare_circuit + encode_circuit + noisy_channel_circuit + detection_circuit +correction_circuit + decode_circuit

display(SVGCircuit(bitflip_circuit))

# Simulating
sim = cirq.Simulator()

result = sim.run(bitflip_circuit, repetitions=100)

hist = cirq.plot_state_histogram(result, plt.subplot(), title='Bit Flip Error Correction', xlabel='States', ylabel='Occurrence', tick_label=binary_labels(1))

plt.show()

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Question 2: Modify the code to prepare the logical qubit in $|+\rangle$ state

# Preparing given state
prepare_circuit = cirq.Circuit()
prepare_circuit.append(cirq.H(qubits[0]))

# Appending Rest of the circuit
bitflip_circuit = prepare_circuit + encode_circuit + noisy_channel_circuit + detection_circuit +correction_circuit + decode_circuit

display(SVGCircuit(bitflip_circuit))

# Print Final State Vector without measuring (decode_circuit)
print("\nFinal State (Without Measurement):")
print(cirq.dirac_notation(cirq.final_state_vector(prepare_circuit + encode_circuit + noisy_channel_circuit + detection_circuit +correction_circuit)))

# Simulating
sim = cirq.Simulator()

result = sim.run(bitflip_circuit, repetitions=100)

hist = cirq.plot_state_histogram(result, plt.subplot(), title='Bit Flip Error Correction', xlabel='States', ylabel='Occurrence', tick_label=binary_labels(1))

plt.show()

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Final State (Without Measurement):
0.71|011⟩ + 0.71|111⟩

Question 3: Modify the code to prepare the logical qubit in $|-\rangle$ state

# Preparing given state
prepare_circuit = cirq.Circuit()
prepare_circuit.append(cirq.X(qubits[0]))
prepare_circuit.append(cirq.H(qubits[0]))

# Appending Rest of the circuit
bitflip_circuit = prepare_circuit + encode_circuit + noisy_channel_circuit + detection_circuit +correction_circuit + decode_circuit

display(SVGCircuit(bitflip_circuit))

# Print Final State Vector without measuring (decode_circuit)
print("\nFinal State (Without Measurement):")
print(cirq.dirac_notation(cirq.final_state_vector(prepare_circuit + encode_circuit + noisy_channel_circuit + detection_circuit +correction_circuit))) 

# Simulating
sim = cirq.Simulator()

result = sim.run(bitflip_circuit, repetitions=100)

hist = cirq.plot_state_histogram(result, plt.subplot(), title='Bit Flip Error Correction', xlabel='States', ylabel='Occurrence', tick_label=binary_labels(1))

plt.show()

findfont: Font family 'Arial' not found.

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Final State (Without Measurement):
0.71|011⟩ - 0.71|111⟩

Discussing Final State Vector: Understanding $|+\rangle$ and $|-\rangle$

Final State Without Measurement

The circuit can produce states like:

$|+\rangle$ State :

$$ 0.71|011\rangle + 0.71|111\rangle $$ This indicates that $q_0$ is in the $|+\rangle$ state. In this 3-qubit encoding, the $|+\rangle$ state is initially prepared on $q_0$ as: $$ |+\rangle = \frac{1}{\sqrt{2}}(|0\rangle + |1\rangle) $$ For the encoded state, $|0\rangle$ corresponds to $|011\rangle$ and $|1\rangle$ to $|111\rangle$, maintaining the superposition.

$|-\rangle$ State :

$$ 0.71|011\rangle - 0.71|111\rangle $$ This indicates that $q_0$ is in the $|-\rangle$ state. The $|-\rangle$ state is initially prepared on $q_0$ as: $$ |-\rangle = \frac{1}{\sqrt{2}}(|0\rangle - |1\rangle) $$ For the encoded state, the phase difference between $|011\rangle$ and $|111\rangle$ shows the negative sign, distinguishing it from the $|+\rangle$ state.

Why Calculate Without Measurement?

1. Preserve Superposition: Measurement collapses quantum states. By avoiding it, we retain the full superposition needed for verifying circuit operations.
2. Quantum Information: Analyzing the unmeasured state allows for a clearer understanding of how quantum information is manipulated and corrected.

Question 4: Modify the code so that the qubit is in the $|0\rangle$ state but there is a bit flip error on both $q_1$ and $q_2$

# Preparing Noises
noisy_channel_circuit = cirq.Circuit()
noisy_channel_circuit.append(cirq.X(qubits[1]))
noisy_channel_circuit.append(cirq.X(qubits[2]))

# Appending Rest of the circuit
bitflip_circuit = encode_circuit + noisy_channel_circuit + detection_circuit +correction_circuit + decode_circuit

display(SVGCircuit(bitflip_circuit))

# Print Final State Vector without measuring (decode_circuit)
print("\nFinal State (Without Measurement):")
print(cirq.dirac_notation(cirq.final_state_vector(encode_circuit + noisy_channel_circuit + detection_circuit +correction_circuit))) 

# Simulating
sim = cirq.Simulator()

result = sim.run(bitflip_circuit, repetitions=100)

hist = cirq.plot_state_histogram(result, plt.subplot(), title='Bit Flip Error Correction', xlabel='States', ylabel='Occurrence', tick_label=binary_labels(1))

plt.show()

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Final State (Without Measurement):
|111⟩

Note : Since two of the qubits are flipped. The result is always wrong.

Conclusion

• In quantum error correction, the accuracy of error correction schemes can be significantly impacted by the number of qubits affected by errors. In our case, when the majority of qubits (2 out of 3) experience phase flip errors, the correction process may fail to restore the logical qubit to its correct state. This is because the error correction code relies on the majority to determine the presence of an error and apply the necessary corrections.

• When most of the qubits are erroneous, the correction mechanism can be overwhelmed, leading to incorrect results. This highlights the importance of having reliable error correction codes and the need for robust schemes capable of handling multiple errors to ensure the fidelity of quantum computations.

• Thus, while error correction codes can effectively handle single errors or a small number of errors, they may struggle when the majority of qubits are affected, underscoring the need for continued advancements in quantum error correction methods.

Part 2: Phase Flip Error Correction

In this section, we implement a quantum error correction code to handle phase flip errors. Phase flip errors invert the phase of a qubit, changing the sign of the phase component in the state vector. This process involves five main steps: encoding, sending over a noisy channel, error detection, error correction, and decoding.

Steps:

1. Encoding:

   • The logical qubit is encoded into three physical qubits using CNOT gates and Hadamard gates. This prepares the qubits in a superposition state that allows for phase flip error detection and correction.

2. Sending Over Noisy Channel:

   • A phase flip error is simulated by applying a Z gate on the first qubit, which inverts the phase of that qubit.

3. Error Detection:

   • Hadamard gates are applied to transform phase errors into bit flip errors, which are easier to detect. CNOT gates are then used to detect discrepancies among the qubits.

4. Error Correction:

   • A CCNOT (Toffoli) gate is used to correct detected errors, ensuring that the logical qubit is restored to its original state.

5. Decoding:

   • The first qubit is measured to decode the corrected logical qubit, retrieving the original quantum information.

This sequence allows for the detection and correction of phase flip errors by leveraging the transformation of phase errors into bit flip errors, which can be more readily detected and corrected using established quantum error correction techniques.

Step 1: Encoding

1.1: Initialize a circuit with 3-Qubits and 1 Classical Bit

qubits = cirq.NamedQubit.range(3, prefix='q')
encode_circuit = cirq.Circuit()

1.2: Entangle the state of $q_0$ with other two qubits

encode_circuit.append(cirq.CNOT(qubits[0], qubits[1]))
encode_circuit.append(cirq.CNOT(qubits[0], qubits[2]))

display(SVGCircuit(encode_circuit))

findfont: Font family 'Arial' not found.

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

1.3: Put all qubits in equal superpositions to correct $|+\rangle$ and $|-\rangle$ states from flipping instead of $|0\rangle$ and $|1\rangle$

encode_circuit.append(cirq.H.on_each(qubits))

display(SVGCircuit(encode_circuit))

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Step 2: Sending Over Noisy Channel

• Creating a new circuit to represent the noisy channel and specifically simulate a phase flip error on $q_0$.
• Note : Z-Gate flips a qubit from $|+\rangle$ to $|-\rangle$ or $|-\rangle$ to $|+\rangle$.

noisy_channel_circuit = cirq.Circuit()

noisy_channel_circuit.append(cirq.Z(qubits[0]))

noisy_channel_circuit

q0: ───Z───

Step 3: Error Detection

• Creating a new circuit to detect if there is been an error by checking the phase ( do the phase agree with each other or different?) of $q_0$ with the other qubits by bringing all the qubits out of superposition (H-Gate)
• Then checking the parity of the $q_0$ with the ancilla qubits by applying to CNOTs controlled by $q_0$ and targeting the ancilla qubits.

Note : Only the part dealing with superposition is different from the bit flip code

detection_circuit = cirq.Circuit()

detection_circuit.append(cirq.H.on_each(qubits))

detection_circuit.append(cirq.CNOT(qubits[0], qubits[2]))
detection_circuit.append(cirq.CNOT(qubits[0], qubits[1]))

display(SVGCircuit(detection_circuit))

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Step 4: Error Correction

• We will now creat a circuit to update $q_0$ if both $q_1$ and $q_2$ have detected a bit flip so that $q_0$ stores the correct logical state.
• Specifically applying the TOFFOLI(CCNOT) gate controlled by $q_2$ and $q_1$, targeting $q_0$.

correction_circuit = cirq.Circuit()

correction_circuit.append(cirq.CCNOT(qubits[2], qubits[1], qubits[0]))

display(SVGCircuit(correction_circuit))

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Step 5: Decoding

• The logical gate has been stored in $q_0$.
• Now creating a decoding circuit to measure this qubit in order to decode the final logical state.

decode_circuit = cirq.Circuit()

decode_circuit.append(cirq.measure(qubits[0]))

decode_circuit

q0: ───M───

Adding the Circuits and Simulating

• Now that we have created all the part of our phaselip_circuit, we will combine all the circuit together and simulate 100 times to ensure our error correction code really works.

phaseflip_circuit = encode_circuit + noisy_channel_circuit + detection_circuit +correction_circuit + decode_circuit

display(SVGCircuit(phaseflip_circuit))

sim = cirq.Simulator()

result = sim.run(phaseflip_circuit, repetitions=100)

hist = cirq.plot_state_histogram(result, plt.subplot(), title='Bit Flip Error Correction', xlabel='States', ylabel='Occurrence', tick_label=binary_labels(1))

plt.show()

findfont: Font family 'Arial' not found.

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Discussion on Error Correction

In the phase flip error correction implementation, the objective is to detect and correct phase flip errors that may occur during quantum information processing. Here’s a detailed breakdown of how the error correction is executed and validated using the provided code:

Error Correction Process

1. Encoding:

   • The logical qubit is encoded into three physical qubits using CNOT gates. This encoding spreads the information of the logical qubit across three qubits, providing redundancy that helps in error detection and correction.

2. Phase Flip Error Introduction:

   • A phase flip error is simulated by applying a Z gate to the first qubit. This introduces a phase inversion in the qubit's state, mimicking real-world noise effects.

3. Transforming Phase Errors:

   • To facilitate error detection, Hadamard gates are applied to all qubits. This transformation converts the phase flip error into a bit flip error, which is easier to detect and correct using standard techniques.

4. Error Detection:

   • CNOT gates are used to detect errors by comparing the states of the qubits. Discrepancies detected through these comparisons signal the presence of an error.

5. Error Correction:

   • The CCNOT (Toffoli) gate is utilized to correct the detected bit flip error. This gate flips the target qubit based on the states of two control qubits, ensuring that the detected error is corrected.

6. Decoding:

   • After error correction, the first qubit is measured to retrieve the logical qubit's state( $|0\rangle$ ). This step confirms that the error correction mechanism has successfully restored the qubit to its intended state.

Simulation and Results

The provided code simulates the entire phase flip error correction process using the following steps:

• Circuit Construction: The phaseflip_circuit combines encoding, noisy channel simulation, error detection, correction, and decoding circuits.
• Simulation: The cirq.Simulator() is used to run the phaseflip_circuit 100 times.
• Result Analysis: The cirq.plot_state_histogram() function generates a histogram of the measurement outcomes, displaying the distribution of states after the correction process.

Discussion of Results

• The histogram results show whether the correction process effectively restores the logical qubit's state ( $|0\rangle$ ). Ideally, the histogram should reflect the corrected state, confirming that the phase flip error was successfully mitigated.

Question 1: Modify the code so that the qubit is in the $|+\rangle$ state instead of $|0\rangle$ state

# Preparing given state
prepare_circuit = cirq.Circuit()
prepare_circuit.append(cirq.H(qubits[0]))

# Appending Rest of the circuit
phaseflip_circuit = prepare_circuit + encode_circuit + noisy_channel_circuit + detection_circuit +correction_circuit + decode_circuit

display(SVGCircuit(phaseflip_circuit))

# Print Final State Vector without measuring (decode_circuit)
print("\nFinal State (Without Measurement):")
print(cirq.dirac_notation(cirq.final_state_vector(prepare_circuit + encode_circuit + noisy_channel_circuit + detection_circuit +correction_circuit))) 

# Simulating
sim = cirq.Simulator()

result = sim.run(phaseflip_circuit, repetitions=100)

hist = cirq.plot_state_histogram(result, plt.subplot(), title='Bit Flip Error Correction', xlabel='States', ylabel='Occurrence', tick_label=binary_labels(1))

plt.show()

findfont: Font family 'Arial' not found.

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Final State (Without Measurement):
0.71|011⟩ + 0.71|111⟩

Question 2: Modify the code so that the qubit is in the $|-\rangle$ state instead of $|0\rangle$ state

# Preparing given state
prepare_circuit = cirq.Circuit()
prepare_circuit.append(cirq.X(qubits[0]))
prepare_circuit.append(cirq.H(qubits[0]))

# Appending Rest of the circuit
phaseflip_circuit = prepare_circuit + encode_circuit + noisy_channel_circuit + detection_circuit +correction_circuit + decode_circuit

display(SVGCircuit(phaseflip_circuit))

# Print Final State Vector without measuring (decode_circuit)
print("\nFinal State (Without Measurement):")
print(cirq.dirac_notation(cirq.final_state_vector(prepare_circuit + encode_circuit + noisy_channel_circuit + detection_circuit +correction_circuit))) 

# Simulating
sim = cirq.Simulator()

result = sim.run(phaseflip_circuit, repetitions=100)

hist = cirq.plot_state_histogram(result, plt.subplot(), title='Bit Flip Error Correction', xlabel='States', ylabel='Occurrence', tick_label=binary_labels(1))

plt.show()

findfont: Font family 'Arial' not found.

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Final State (Without Measurement):
0.71|011⟩ - 0.71|111⟩

Discussing Final State Vector: Understanding $|+\rangle$ and $|-\rangle$

Final State Without Measurement

The circuit can produce states like:

$|+\rangle$ State :

$$ 0.71|011\rangle + 0.71|111\rangle $$ This indicates that $q_0$ is in the $|+\rangle$ state. In this 3-qubit encoding, the $|+\rangle$ state is initially prepared on $q_0$ as: $$ |+\rangle = \frac{1}{\sqrt{2}}(|0\rangle + |1\rangle) $$ For the encoded state, $|0\rangle$ corresponds to $|011\rangle$ and $|1\rangle$ to $|111\rangle$, maintaining the superposition.

$|-\rangle$ State :

$$ 0.71|011\rangle - 0.71|111\rangle $$ This indicates that $q_0$ is in the $|-\rangle$ state. The $|-\rangle$ state is initially prepared on $q_0$ as: $$ |-\rangle = \frac{1}{\sqrt{2}}(|0\rangle - |1\rangle) $$ For the encoded state, the phase difference between $|011\rangle$ and $|111\rangle$ shows the negative sign, distinguishing it from the $|+\rangle$ state.

Why Calculate Without Measurement?

1. Preserve Superposition: Measurement collapses quantum states. By avoiding it, we retain the full superposition needed for verifying circuit operations.
2. Quantum Information: Analyzing the unmeasured state allows for a clearer understanding of how quantum information is manipulated and corrected.

Question 3: Modify the code so that the qubit is in the $|0\rangle$ state but there is a phase flip error on both $q_1$ and $q_2$

# Preparing Noises
noisy_channel_circuit = cirq.Circuit()
noisy_channel_circuit.append(cirq.Z(qubits[1]))
noisy_channel_circuit.append(cirq.Z(qubits[2]))

# Appending Rest of the circuit
phaseflip_circuit = encode_circuit + noisy_channel_circuit + detection_circuit +correction_circuit + decode_circuit

display(SVGCircuit(phaseflip_circuit))

# Print Final State Vector without measuring (decode_circuit)
print("\nFinal State (Without Measurement):")
print(cirq.dirac_notation(cirq.final_state_vector(encode_circuit + noisy_channel_circuit + detection_circuit +correction_circuit))) 

# Simulating
sim = cirq.Simulator()

result = sim.run(phaseflip_circuit, repetitions=100)

hist = cirq.plot_state_histogram(result, plt.subplot(), title='Bit Flip Error Correction', xlabel='States', ylabel='Occurrence', tick_label=binary_labels(1))

plt.show()

findfont: Font family 'Arial' not found.

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Final State (Without Measurement):
|111⟩

Conclusion

• In quantum error correction, the accuracy of error correction schemes can be significantly impacted by the number of qubits affected by errors. In our case, when the majority of qubits (2 out of 3) experience phase flip errors, the correction process may fail to restore the logical qubit to its correct state. This is because the error correction code relies on the majority to determine the presence of an error and apply the necessary corrections.

• When most of the qubits are erroneous, the correction mechanism can be overwhelmed, leading to incorrect results. This highlights the importance of having reliable error correction codes and the need for robust schemes capable of handling multiple errors to ensure the fidelity of quantum computations.

• Thus, while error correction codes can effectively handle single errors or a small number of errors, they may struggle when the majority of qubits are affected, underscoring the need for continued advancements in quantum error correction methods.

2.1 Bb84 Protocol

BB84 Quantum Key Distribution Protocol

Phase 1: Alice Sends the Qubits

Step 1: Alice Randomly Chooses Bits

• Alice generates a random sequence of bits.

Step 2: Alice Randomly Chooses Basis

• For each bit, Alice randomly decides whether to encode it in the standard (Z) basis (0) or the Hadamard (X) basis (1).

Step 3: Alice Encodes the Qubits

• Alice prepares each qubit according to her random bit sequence and basis choices:
  • If the basis is 0 (Z-basis), she sets the qubit to either |0⟩ or |1⟩.
  • If the basis is 1 (X-basis), she sets the qubit to either |+⟩ or |-⟩.

Phase 2: Bob Receives The Qubits

Step 4: Bob Randomly Chooses Basis

• Bob independently chooses a measurement basis (0 for Z-basis or 1 for X-basis) for each received qubit.

Step 5: Bob Applies Basis to Qubits

• Bob applies the chosen basis gate to each qubit received from Alice.

Step 6: Bob Measures the Qubits

• Using his chosen bases, Bob measures each qubit to obtain measurement outcomes.

Step 7: Combining Alice's and Bob's Circuits

• The circuits from Alice and Bob are combined to simulate the entire quantum key distribution process.

Phase 3: Alice and Bob Compare

Step 8: Key Reconciliation

• Alice and Bob compare their chosen bases for each qubit.

Step 9: Error Correction and Privacy Amplification

• They perform error checking to ensure the integrity of the shared key and apply privacy amplification techniques to distill a shorter, secure shared key that is resistant to eavesdropping.

Step 0: The Set Up

1. Define a Dictionary for Encoding Gates:

   • This dictionary specifies which gate to apply based on the bit value (0 or 1).
   • For bit value 0, no gate is applied (identity operation).
   • For bit value 1, an X gate (Pauli-X gate) is applied.

2. Define a Dictionary for Basis Gates:

   • This dictionary specifies which gate to apply based on the basis (standard or Hadamard).
   • For standard basis, no gate is applied.
   • For Hadamard basis, a Hadamard gate (H gate) is applied.

3. Create a List of Named Qubits:

   • Create a list of qubits with specific names for better identification in the circuit.

import cirq
from cirq.contrib.svg import SVGCircuit

encode_gates = {0: cirq.I, 1: cirq.X}

basis_gates = {'Z': cirq.I, 'X': cirq.H}

num_bits = 10
qubits = cirq.NamedQubit.range(num_bits, prefix='q')

Implementing the Steps

Phase 1: Alise sends the Qubits

Step 1: Alice Randomly Chooses Bits

• Alice uses the choices() function from the random module to generate a key of random bits that is num_bits long.
• For example, choices([0, 1], k=num_bits) generates a list of random bits of the specified length.

from random import choices

alice_key = choices([0, 1], k=num_bits)
print("Alice\'s Initial Key: ", alice_key)

Alice's Initial Key:  [0, 0, 0, 1, 0, 0, 0, 1, 0, 1]

Step 2: Alice Randomly Chooses Basis

Alice randomly chooses between the Z or X basis for each qubit, repeating this process num_bits times.

alice_bases = choices(['X', 'Z'], k=num_bits)
print("Alice\'s randomly choosen bases: ", alice_bases)

Alice's randomly choosen bases:  ['X', 'Z', 'X', 'Z', 'Z', 'Z', 'X', 'Z', 'X', 'Z']

Step 3: Alice Encodes the Qubits

Alice encodes the qubits based on her chosen bits and bases. She does this by following these steps:

1. Create a Circuit:

   • Initialize an empty circuit named alice_circuit.

2. Iterate Over Each Bit:

   • For each bit in the range of num_bits, Alice performs the following operations:

3. Determine the Encoding Gate:

   • encode_value = alice_keys[bit]: Get the bit value (0 or 1) from Alice's key.
   • encode_gate = encode_gates[encode_value]: Select the corresponding gate (I or X) based on the bit value. This is because every qubit is in the 0 state by default, so if encode_value is 0, it applies the identity gate and does nothing; if 1, then it applies the X-Gate and flips the qubit from 0 to 1.

4. Determine the Basis Gate:

   • basis_value = alice_bases[bit]: Get the basis value (X or Z) from Alice's chosen bases.
   • basis_gate = basis_gates[basis_value]: Select the corresponding gate (I or H) based on the basis value.

5. Apply the Gates to the Qubits:

   • qubit = my_qubits[bit]: Get the qubit corresponding to the current bit.
   • alice_circuit.append(encode_gate(qubit)): Apply the encoding gate (I or X) to the qubit.
   • alice_circuit.append(basis_gate(qubit)): Apply the basis gate (I or H) to the qubit.

This process ensures that each qubit is encoded according to Alice's random choices of bits and bases. The resulting circuit (alice_circuit) represents the quantum state that Alice will send to Bob.

alice_cirquit = cirq.Circuit()

for bit in range(num_bits):
    
    encode_value = alice_key[bit]
    encode_gate = encode_gates[encode_value]
    
    basis_value = alice_bases[bit]
    basis_gate = basis_gates[basis_value]
    
    qubit = qubits[bit]
    alice_cirquit.append(encode_gate(qubit))
    alice_cirquit.append(basis_gate(qubit))
    
print("Alice\'s Phase 1 Circuit: \n\n", alice_cirquit)

Alice's Phase 1 Circuit: 

 q0: ───I───H───

q1: ───I───I───

q2: ───I───H───

q3: ───X───I───

q4: ───I───I───

q5: ───I───I───

q6: ───I───H───

q7: ───X───I───

q8: ───I───H───

q9: ───X───I───

Phase 2: Bob Recieves The Qubits

Step 4: Bob Randomly Chooses Basis

• Bob randomly chooses Z or X basis for num_bits times, independently of Alice's choices.
• This is similar to Alice's process, ensuring that the bases are chosen without any prior knowledge of Alice's choices.

bob_bases = choices(['X', 'Z'], k= num_bits)
print("Bob\'s randomly choosen bases: ", bob_bases)

Bob's randomly choosen bases:  ['X', 'Z', 'X', 'X', 'Z', 'X', 'X', 'Z', 'Z', 'Z']

Step 5: Bob Applies Basis to Qubits

Bob applies his chosen bases to the qubits received from Alice. He does this by following these steps:

1. Create a Circuit:

   • Initialize an empty circuit named bob_circuit.

2. Iterate Over Each Bit:

   • For each bit in the range of num_bits, Bob performs the following operations:

3. Determine the Basis Gate:

   • basis_value = bob_bases[bit]: Get the basis value (X or Z) from Bob's chosen bases.
   • basis_gate = basis_gates[basis_value]: Select the corresponding gate (I or H) based on the basis value.

4. Apply the Basis Gate to the Qubits:

   • qubit = qubits[bit]: Get the qubit corresponding to the current bit.
   • bob_circuit.append(basis_gate(qubit)): Apply the basis gate (I or H) to the qubit.

This process ensures that Bob applies his randomly chosen bases to each qubit received from Alice. The resulting circuit (bob_circuit) represents the quantum operations Bob performs on the qubits before measuring them.

bob_circuit = cirq.Circuit()

for bit in range(num_bits):
    
    basis_value =  bob_bases[bit]
    basis_gate = basis_gates[basis_value]
    
    qubit = qubits[bit]
    bob_circuit.append(basis_gate(qubit))
    

Step 6: Bob Measures the Qubits

In this step, Bob measures the qubits after applying his chosen bases. He does this by following these steps:

1. Add Measurement Operations:

   • For each qubit in qubits, Bob adds a measurement operation to the circuit. This allows Bob to observe the state of each qubit.

2. Measure the Qubits:

   • bob_circuit.append(cirq.measure(qubits, key='bob_key')): Append a measurement gate to all the qubits in the circuit. The measure function takes in the qubits and a key name (bob_key) which will be used to access the measurement results. This gate measures the state of each qubit and records the result using the specified key.

The resulting circuit (bob_circuit) now includes both the basis gates and the measurement operations. When executed, this circuit will provide the measurement results for each qubit, allowing Bob to compare his results with Alice's original bits.

bob_circuit.append(cirq.measure(qubits, key= 'bob_key'))

print("Bob\'s Phase 2 Circuit: \n\n")

Bob's Phase 2 Circuit: 

Step 7: Combining Alice's and Bob's Circuits

In this step, we combine Alice's and Bob's circuits and simulate the BB84 protocol:

1. Combine Circuits:

   • bb84_circuit = alice_circuit + bob_circuit: Combine Alice's circuit (alice_circuit) and Bob's circuit (bob_circuit) to create a complete BB84 circuit (bb84_circuit). This combined circuit represents the entire quantum communication process between Alice and Bob.

2. Simulate the Combined Circuit:

   • sim = cirq.Simulator(): Initialize a Cirq simulator.
   • results = sim.run(bb84_circuit): Run the combined circuit using the simulator. The simulation executes the quantum operations and measurements specified in the circuit.

3. Extract Bob's Measurement Results:

   • bob_key = results.measurements['bob_key'][0]: Extract Bob's measurement results from the simulation output. The results.measurements dictionary contains the measurement results keyed by the specified measurement name ('bob_key'). The [0] index retrieves the first set of measurement results.

This process simulates the BB84 protocol, combining Alice's and Bob's quantum operations and providing the measurement results that Bob obtains after the quantum communication. These results can then be used to compare with Alice's original bits and bases to determine the shared secret key.

bb84_circuit = alice_cirquit + bob_circuit

sim = cirq.Simulator()
results = sim.run(bb84_circuit)

bob_key = results.measurements['bob_key'][0]

print("Bob\'s inital key: ", bob_key)

Bob's inital key:  [0 0 0 1 0 1 0 1 1 1]

Phase 3: Alice and Bob Compare

Step 8: Key Reconciliation

After Alice and Bob have measured their qubits, they need to compare their bases to determine the final shared key. Here's how they do it:

• Compare Bases:
  • for bit in range(num_bits): Iterate over each bit in the range of num_bits.
  • if (alice_bases[bit] == bob_bases[bit]): Check if the basis chosen by Alice for the current bit matches the basis chosen by Bob.
    • If the bases match:
      • final_alice_key.append(alice_keys[bit]): Append the bit from Alice's key to the final key list for Alice.
      • final_bob_key.append(bob_key[bit]): Append the corresponding bit from Bob's measurement results to the final key list for Bob.

This process ensures that only the bits where Alice's and Bob's bases matched are included in the final shared key. The final keys for Alice and Bob should be identical if no eavesdropping occurred, forming a secure shared secret key.

final_alice_key = []
final_bob_key = []

for bit in range (num_bits):
    
    if(alice_bases[bit] == bob_bases[bit]):
        final_alice_key.append(alice_key[bit])
        final_bob_key.append(bob_key[bit])
        
print("Final Alice\'s Key : ", final_alice_key)
print("\nFinal Bob\'s Key : ", final_bob_key)

Final Alice's Key :  [0, 0, 0, 0, 0, 1, 1]

Final Bob's Key :  [0, 0, 0, 0, 0, 1, 1]

Step 9: Error Correction and Privacy Amplification

After comparing their keys, Alice and Bob perform error correction and privacy amplification:

1. Initial Key Matching:
   • if (final_alice_key[0] == final_bob_key[0]): Check if the first bit of Alice's final key matches the first bit of Bob's final key.

     • If they match:

       • final_alice_key = final_alice_key[1:]: Remove the first bit from Alice's final key.
       • final_bob_key = final_bob_key[1:]: Remove the first bit from Bob's final key.
       • Print a confirmation message that they can use the remaining keys securely:

     • If they do not match:

       • Print a message indicating that eavesdropping may have occurred and they need to use a different channel:

This step ensures that Alice and Bob verify the integrity of their shared key. If the initial bits match, they proceed to use the remaining bits as their secure key. If there is a mismatch, they suspect eavesdropping and take appropriate measures to secure their communication channel.

if(final_alice_key[0] == final_bob_key[0]):
    final_alice_key = final_alice_key[1:]
    final_bob_key = final_bob_key[1:]
    
    print("\n\n We can use our keys!\n")
    print("Alice\'s Key: ", final_alice_key)
    print("Bob\'s Key: ", final_bob_key)

else:
    print("\n\nEve was lisening. We need to use a different channel!")

 We can use our keys!

Alice's Key:  [0, 0, 0, 0, 1, 1]
Bob's Key:  [0, 0, 0, 0, 1, 1]

2.2 Eve Attakacks Bb84 Protocol

Eve is Attacking !!!

Intercept and Resend Attack on BB84 Protocol

In the BB84 quantum key distribution protocol, a measurement attack (or intercept-resend attack) by an eavesdropper (Eve) involves intercepting the qubits sent by the sender (Alice), measuring them, and then resending new qubits to the receiver (Bob). This kind of attack can be detected due to the fundamental principles of quantum mechanics.

How Eve's Attack Works:

1. Interception and Measurement:

   • Eve intercepts each qubit sent by Alice.
   • Eve measures each qubit in a randomly chosen basis (either the rectilinear basis $|0\rangle$ , $|0\rangle$ or the diagonal basis $|+\rangle$, $|-\rangle$).

2. Resending the Qubit:

   • After measuring the qubit, Eve resends a new qubit to Bob based on her measurement result.

3. Detection by Alice and Bob:

   • Bob receives the qubits and measures them in his randomly chosen basis (either rectilinear or diagonal).
   • After transmission, Alice and Bob publicly compare a subset of their measurement bases (without revealing the actual measurement results).
   • If Eve's basis choice matches Alice's basis choice, Bob's measurement will be correct. However, if Eve's basis choice does not match Alice's basis choice, Bob's measurement result will be random.
   • This introduces errors in the shared key.

4. Error Rate Analysis:

   • Alice and Bob compare a subset of their results to estimate the error rate.
   • If the error rate exceeds a certain threshold (e.g., 50%), they can conclude that an eavesdropper is present and the key is compromised.

Simulation of a Measurement Attack:

The following code simulates a simple BB84 protocol with Eve performing a measurement attack. The simulation illustrates how the error rate increases due to Eve's intervention.

Step 0: The Set Up (100 Qubits)

import cirq

encode_gates = {0: cirq.I, 1: cirq.X}

basis_gates = {'Z': cirq.I, 'X': cirq.H}

num_bits = 100  # using lfew qubits may lead us to error
qubits = cirq.NamedQubit.range(num_bits, prefix='q')

Phase 1: Alise sends the Qubits

from random import choices

alice_key = choices([0, 1], k=num_bits)
print("Alice\'s Initial Key: ", alice_key)



alice_bases = choices(['X', 'Z'], k=num_bits)
print("Alice\'s randomly choosen bases: ", alice_bases)



alice_cirquit = cirq.Circuit()

for bit in range(num_bits):
    
    encode_value = alice_key[bit]
    encode_gate = encode_gates[encode_value]
    
    basis_value = alice_bases[bit]
    basis_gate = basis_gates[basis_value]
    
    qubit = qubits[bit]
    alice_cirquit.append(encode_gate(qubit))
    alice_cirquit.append(basis_gate(qubit))
    
print("Alice\'s Phase 1 Circuit: \n\n", alice_cirquit)

Alice's Initial Key:  [1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1]
Alice's randomly choosen bases:  ['X', 'X', 'X', 'X', 'X', 'Z', 'Z', 'X', 'X', 'Z', 'X', 'Z', 'X', 'X', 'Z', 'Z', 'X', 'Z', 'X', 'Z', 'Z', 'Z', 'Z', 'X', 'X', 'Z', 'Z', 'X', 'X', 'X', 'Z', 'X', 'Z', 'X', 'Z', 'Z', 'X', 'Z', 'Z', 'X', 'X', 'Z', 'X', 'Z', 'Z', 'X', 'Z', 'Z', 'X', 'X', 'X', 'Z', 'X', 'X', 'Z', 'Z', 'X', 'X', 'X', 'X', 'Z', 'X', 'Z', 'X', 'Z', 'Z', 'Z', 'Z', 'X', 'X', 'Z', 'X', 'Z', 'Z', 'Z', 'Z', 'X', 'X', 'Z', 'Z', 'Z', 'X', 'Z', 'Z', 'X', 'X', 'Z', 'Z', 'Z', 'Z', 'X', 'X', 'X', 'Z', 'X', 'X', 'X', 'Z', 'X', 'X']
Alice's Phase 1 Circuit: 

 q0: ────X───H───

q1: ────X───H───

q2: ────X───H───

q3: ────X───H───

q4: ────X───H───

q5: ────I───I───

q6: ────I───I───

q7: ────X───H───

q8: ────I───H───

q9: ────X───I───

q10: ───X───H───

q11: ───X───I───

q12: ───X───H───

q13: ───X───H───

q14: ───X───I───

q15: ───I───I───

q16: ───X───H───

q17: ───X───I───

q18: ───I───H───

q19: ───I───I───

q20: ───I───I───

q21: ───X───I───

q22: ───I───I───

q23: ───I───H───

q24: ───I───H───

q25: ───I───I───

q26: ───I───I───

q27: ───X───H───

q28: ───X───H───

q29: ───X───H───

q30: ───X───I───

q31: ───X───H───

q32: ───X───I───

q33: ───X───H───

q34: ───I───I───

q35: ───X───I───

q36: ───I───H───

q37: ───X───I───

q38: ───X───I───

q39: ───I───H───

q40: ───I───H───

q41: ───X───I───

q42: ───I───H───

q43: ───I───I───

q44: ───X───I───

q45: ───I───H───

q46: ───X───I───

q47: ───X───I───

q48: ───X───H───

q49: ───X───H───

q50: ───X───H───

q51: ───X───I───

q52: ───I───H───

q53: ───X───H───

q54: ───I───I───

q55: ───I───I───

q56: ───I───H───

q57: ───I───H───

q58: ───X───H───

q59: ───X───H───

q60: ───X───I───

q61: ───I───H───

q62: ───X───I───

q63: ───I───H───

q64: ───I───I───

q65: ───X───I───

q66: ───I───I───

q67: ───I───I───

q68: ───X───H───

q69: ───X───H───

q70: ───X───I───

q71: ───I───H───

q72: ───X───I───

q73: ───X───I───

q74: ───I───I───

q75: ───I───I───

q76: ───X───H───

q77: ───I───H───

q78: ───X───I───

q79: ───X───I───

q80: ───I───I───

q81: ───I───H───

q82: ───X───I───

q83: ───I───I───

q84: ───X───H───

q85: ───I───H───

q86: ───I───I───

q87: ───I───I───

q88: ───I───I───

q89: ───X───I───

q90: ───X───H───

q91: ───I───H───

q92: ───X───H───

q93: ───I───I───

q94: ───X───H───

q95: ───X───H───

q96: ───X───H───

q97: ───I───I───

q98: ───I───H───

q99: ───X───H───

Attacking Phase

Step 1: Eve Measures the Qubits

In this step, Eve intercepts the qubits sent by Alice and measures them to determine their values.

eve_circuit = cirq.Circuit()

eve_circuit.append(cirq.measure(qubits, key='eve_key'))

print(eve_circuit)

q0: ────M('eve_key')───
        │
q1: ────M──────────────
        │
q2: ────M──────────────
        │
q3: ────M──────────────
        │
q4: ────M──────────────
        │
q5: ────M──────────────
        │
q6: ────M──────────────
        │
q7: ────M──────────────
        │
q8: ────M──────────────
        │
q9: ────M──────────────
        │
q10: ───M──────────────
        │
q11: ───M──────────────
        │
q12: ───M──────────────
        │
q13: ───M──────────────
        │
q14: ───M──────────────
        │
q15: ───M──────────────
        │
q16: ───M──────────────
        │
q17: ───M──────────────
        │
q18: ───M──────────────
        │
q19: ───M──────────────
        │
q20: ───M──────────────
        │
q21: ───M──────────────
        │
q22: ───M──────────────
        │
q23: ───M──────────────
        │
q24: ───M──────────────
        │
q25: ───M──────────────
        │
q26: ───M──────────────
        │
q27: ───M──────────────
        │
q28: ───M──────────────
        │
q29: ───M──────────────
        │
q30: ───M──────────────
        │
q31: ───M──────────────
        │
q32: ───M──────────────
        │
q33: ───M──────────────
        │
q34: ───M──────────────
        │
q35: ───M──────────────
        │
q36: ───M──────────────
        │
q37: ───M──────────────
        │
q38: ───M──────────────
        │
q39: ───M──────────────
        │
q40: ───M──────────────
        │
q41: ───M──────────────
        │
q42: ───M──────────────
        │
q43: ───M──────────────
        │
q44: ───M──────────────
        │
q45: ───M──────────────
        │
q46: ───M──────────────
        │
q47: ───M──────────────
        │
q48: ───M──────────────
        │
q49: ───M──────────────
        │
q50: ───M──────────────
        │
q51: ───M──────────────
        │
q52: ───M──────────────
        │
q53: ───M──────────────
        │
q54: ───M──────────────
        │
q55: ───M──────────────
        │
q56: ───M──────────────
        │
q57: ───M──────────────
        │
q58: ───M──────────────
        │
q59: ───M──────────────
        │
q60: ───M──────────────
        │
q61: ───M──────────────
        │
q62: ───M──────────────
        │
q63: ───M──────────────
        │
q64: ───M──────────────
        │
q65: ───M──────────────
        │
q66: ───M──────────────
        │
q67: ───M──────────────
        │
q68: ───M──────────────
        │
q69: ───M──────────────
        │
q70: ───M──────────────
        │
q71: ───M──────────────
        │
q72: ───M──────────────
        │
q73: ───M──────────────
        │
q74: ───M──────────────
        │
q75: ───M──────────────
        │
q76: ───M──────────────
        │
q77: ───M──────────────
        │
q78: ───M──────────────
        │
q79: ───M──────────────
        │
q80: ───M──────────────
        │
q81: ───M──────────────
        │
q82: ───M──────────────
        │
q83: ───M──────────────
        │
q84: ───M──────────────
        │
q85: ───M──────────────
        │
q86: ───M──────────────
        │
q87: ───M──────────────
        │
q88: ───M──────────────
        │
q89: ───M──────────────
        │
q90: ───M──────────────
        │
q91: ───M──────────────
        │
q92: ───M──────────────
        │
q93: ───M──────────────
        │
q94: ───M──────────────
        │
q95: ───M──────────────
        │
q96: ───M──────────────
        │
q97: ───M──────────────
        │
q98: ───M──────────────
        │
q99: ───M──────────────

Step 2: Eve Generates Her Key

Eve combines her circuit with Alice's circuit to simulate her measurement and generate her key.

eve_intercept_circuit = alice_cirquit + eve_circuit

sim = cirq.Simulator()
results = sim.run(eve_intercept_circuit)
eve_key = results.measurements['eve_key'][0]

print("Eve\'s Circuit: \n\n", eve_intercept_circuit)

Eve's Circuit: 

 q0: ────X───H───M('eve_key')───
                │
q1: ────X───H───M──────────────
                │
q2: ────X───H───M──────────────
                │
q3: ────X───H───M──────────────
                │
q4: ────X───H───M──────────────
                │
q5: ────I───I───M──────────────
                │
q6: ────I───I───M──────────────
                │
q7: ────X───H───M──────────────
                │
q8: ────I───H───M──────────────
                │
q9: ────X───I───M──────────────
                │
q10: ───X───H───M──────────────
                │
q11: ───X───I───M──────────────
                │
q12: ───X───H───M──────────────
                │
q13: ───X───H───M──────────────
                │
q14: ───X───I───M──────────────
                │
q15: ───I───I───M──────────────
                │
q16: ───X───H───M──────────────
                │
q17: ───X───I───M──────────────
                │
q18: ───I───H───M──────────────
                │
q19: ───I───I───M──────────────
                │
q20: ───I───I───M──────────────
                │
q21: ───X───I───M──────────────
                │
q22: ───I───I───M──────────────
                │
q23: ───I───H───M──────────────
                │
q24: ───I───H───M──────────────
                │
q25: ───I───I───M──────────────
                │
q26: ───I───I───M──────────────
                │
q27: ───X───H───M──────────────
                │
q28: ───X───H───M──────────────
                │
q29: ───X───H───M──────────────
                │
q30: ───X───I───M──────────────
                │
q31: ───X───H───M──────────────
                │
q32: ───X───I───M──────────────
                │
q33: ───X───H───M──────────────
                │
q34: ───I───I───M──────────────
                │
q35: ───X───I───M──────────────
                │
q36: ───I───H───M──────────────
                │
q37: ───X───I───M──────────────
                │
q38: ───X───I───M──────────────
                │
q39: ───I───H───M──────────────
                │
q40: ───I───H───M──────────────
                │
q41: ───X───I───M──────────────
                │
q42: ───I───H───M──────────────
                │
q43: ───I───I───M──────────────
                │
q44: ───X───I───M──────────────
                │
q45: ───I───H───M──────────────
                │
q46: ───X───I───M──────────────
                │
q47: ───X───I───M──────────────
                │
q48: ───X───H───M──────────────
                │
q49: ───X───H───M──────────────
                │
q50: ───X───H───M──────────────
                │
q51: ───X───I───M──────────────
                │
q52: ───I───H───M──────────────
                │
q53: ───X───H───M──────────────
                │
q54: ───I───I───M──────────────
                │
q55: ───I───I───M──────────────
                │
q56: ───I───H───M──────────────
                │
q57: ───I───H───M──────────────
                │
q58: ───X───H───M──────────────
                │
q59: ───X───H───M──────────────
                │
q60: ───X───I───M──────────────
                │
q61: ───I───H───M──────────────
                │
q62: ───X───I───M──────────────
                │
q63: ───I───H───M──────────────
                │
q64: ───I───I───M──────────────
                │
q65: ───X───I───M──────────────
                │
q66: ───I───I───M──────────────
                │
q67: ───I───I───M──────────────
                │
q68: ───X───H───M──────────────
                │
q69: ───X───H───M──────────────
                │
q70: ───X───I───M──────────────
                │
q71: ───I───H───M──────────────
                │
q72: ───X───I───M──────────────
                │
q73: ───X───I───M──────────────
                │
q74: ───I───I───M──────────────
                │
q75: ───I───I───M──────────────
                │
q76: ───X───H───M──────────────
                │
q77: ───I───H───M──────────────
                │
q78: ───X───I───M──────────────
                │
q79: ───X───I───M──────────────
                │
q80: ───I───I───M──────────────
                │
q81: ───I───H───M──────────────
                │
q82: ───X───I───M──────────────
                │
q83: ───I───I───M──────────────
                │
q84: ───X───H───M──────────────
                │
q85: ───I───H───M──────────────
                │
q86: ───I───I───M──────────────
                │
q87: ───I───I───M──────────────
                │
q88: ───I───I───M──────────────
                │
q89: ───X───I───M──────────────
                │
q90: ───X───H───M──────────────
                │
q91: ───I───H───M──────────────
                │
q92: ───X───H───M──────────────
                │
q93: ───I───I───M──────────────
                │
q94: ───X───H───M──────────────
                │
q95: ───X───H───M──────────────
                │
q96: ───X───H───M──────────────
                │
q97: ───I───I───M──────────────
                │
q98: ───I───H───M──────────────
                │
q99: ───X───H───M──────────────

Step 3: Eve Trying to Fool Bob

Eve attempts to resend the qubits to Bob in a way that he won't detect the interception.

• Eve measures each intercepted qubit to obtain its value.
• She then chooses a random basis (either 'X' or 'Z') for each qubit, similar to Bob's random choice.
• Eve encodes each qubit again based on her measurement results and chosen basis.
• This process aims to mimic Alice's original encoding but with potential alterations due to Eve's interception and measurement.

alice_cirquit = cirq.Circuit()

eve_bases = choices(['X', 'Z'], k= num_bits)

for bit in range(num_bits):
    
    encode_value = eve_key[bit]
    encode_gate = encode_gates[encode_value]
    
    basis_value = eve_bases[bit]
    basis_gate = basis_gates[basis_value]
    
    qubit = qubits[bit]
    alice_cirquit.append(encode_gate(qubit))
    alice_cirquit.append(basis_gate(qubit))

print("Alice\'s Circuit after Eve\'s interception: \n", alice_cirquit)

Alice's Circuit after Eve's interception: 
 q0: ────I───H───

q1: ────X───I───

q2: ────X───H───

q3: ────I───H───

q4: ────X───H───

q5: ────I───I───

q6: ────I───H───

q7: ────X───H───

q8: ────I───I───

q9: ────X───I───

q10: ───I───H───

q11: ───X───H───

q12: ───I───H───

q13: ───I───I───

q14: ───X───H───

q15: ───I───I───

q16: ───X───H───

q17: ───X───I───

q18: ───I───H───

q19: ───I───H───

q20: ───I───H───

q21: ───X───I───

q22: ───I───H───

q23: ───X───H───

q24: ───X───H───

q25: ───I───I───

q26: ───I───I───

q27: ───X───H───

q28: ───X───I───

q29: ───I───I───

q30: ───X───H───

q31: ───I───I───

q32: ───X───I───

q33: ───I───H───

q34: ───I───I───

q35: ───X───H───

q36: ───I───H───

q37: ───X───I───

q38: ───X───H───

q39: ───I───I───

q40: ───X───I───

q41: ───X───H───

q42: ───X───H───

q43: ───I───H───

q44: ───X───H───

q45: ───X───I───

q46: ───X───I───

q47: ───X───I───

q48: ───X───H───

q49: ───I───H───

q50: ───I───I───

q51: ───X───I───

q52: ───X───I───

q53: ───X───H───

q54: ───I───H───

q55: ───I───H───

q56: ───I───I───

q57: ───X───I───

q58: ───X───I───

q59: ───I───H───

q60: ───X───H───

q61: ───X───I───

q62: ───X───H───

q63: ───I───I───

q64: ───I───H───

q65: ───X───H───

q66: ───I───I───

q67: ───I───H───

q68: ───X───I───

q69: ───I───I───

q70: ───X───H───

q71: ───X───I───

q72: ───X───I───

q73: ───X───I───

q74: ───I───I───

q75: ───I───H───

q76: ───X───H───

q77: ───I───H───

q78: ───X───I───

q79: ───X───H───

q80: ───I───I───

q81: ───I───H───

q82: ───X───H───

q83: ───I───I───

q84: ───I───H───

q85: ───X───H───

q86: ───I───I───

q87: ───I───H───

q88: ───I───I───

q89: ───X───I───

q90: ───I───I───

q91: ───X───H───

q92: ───I───I───

q93: ───I───H───

q94: ───I───H───

q95: ───X───I───

q96: ───X───I───

q97: ───I───I───

q98: ───I───I───

q99: ───I───I───

Phase 2: Bob Recieves The Qubits

bob_bases = choices(['X', 'Z'], k= num_bits)
print("Bob\'s randomly choosen bases: ", bob_bases)




bob_circuit = cirq.Circuit()

for bit in range(num_bits):
    
    basis_value =  bob_bases[bit]
    basis_gate = basis_gates[basis_value]
    
    qubit = qubits[bit]
    bob_circuit.append(basis_gate(qubit))
    


    
bob_circuit.append(cirq.measure(qubits, key= 'bob_key'))

print("\n\nBob\'s Phase 2 Circuit: \n\n",  bob_circuit)




bb84_circuit = alice_cirquit + bob_circuit

sim = cirq.Simulator()
results = sim.run(bb84_circuit)

bob_key = results.measurements['bob_key'][0]

print("\n\nBob\'s inital key: ", bob_key)

Bob's randomly choosen bases:  ['Z', 'X', 'X', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'X', 'X', 'Z', 'X', 'X', 'Z', 'Z', 'X', 'X', 'X', 'Z', 'X', 'Z', 'X', 'Z', 'X', 'X', 'Z', 'Z', 'X', 'X', 'X', 'Z', 'Z', 'X', 'X', 'Z', 'Z', 'X', 'X', 'Z', 'Z', 'Z', 'X', 'X', 'Z', 'X', 'Z', 'X', 'X', 'X', 'X', 'Z', 'Z', 'X', 'Z', 'Z', 'X', 'X', 'Z', 'Z', 'Z', 'X', 'X', 'X', 'Z', 'X', 'Z', 'X', 'X', 'Z', 'Z', 'X', 'X', 'X', 'X', 'Z', 'X', 'Z', 'X', 'Z', 'Z', 'Z', 'X', 'Z', 'Z', 'X', 'Z', 'Z', 'X', 'X', 'Z', 'X', 'X', 'X', 'Z', 'Z', 'Z', 'X', 'X']


Bob's Phase 2 Circuit: 

 q0: ────I───M('bob_key')───
            │
q1: ────H───M──────────────
            │
q2: ────H───M──────────────
            │
q3: ────I───M──────────────
            │
q4: ────I───M──────────────
            │
q5: ────I───M──────────────
            │
q6: ────I───M──────────────
            │
q7: ────I───M──────────────
            │
q8: ────I───M──────────────
            │
q9: ────I───M──────────────
            │
q10: ───H───M──────────────
            │
q11: ───H───M──────────────
            │
q12: ───I───M──────────────
            │
q13: ───H───M──────────────
            │
q14: ───H───M──────────────
            │
q15: ───I───M──────────────
            │
q16: ───I───M──────────────
            │
q17: ───H───M──────────────
            │
q18: ───H───M──────────────
            │
q19: ───H───M──────────────
            │
q20: ───I───M──────────────
            │
q21: ───H───M──────────────
            │
q22: ───I───M──────────────
            │
q23: ───H───M──────────────
            │
q24: ───I───M──────────────
            │
q25: ───H───M──────────────
            │
q26: ───H───M──────────────
            │
q27: ───I───M──────────────
            │
q28: ───I───M──────────────
            │
q29: ───H───M──────────────
            │
q30: ───H───M──────────────
            │
q31: ───H───M──────────────
            │
q32: ───I───M──────────────
            │
q33: ───I───M──────────────
            │
q34: ───H───M──────────────
            │
q35: ───H───M──────────────
            │
q36: ───I───M──────────────
            │
q37: ───I───M──────────────
            │
q38: ───H───M──────────────
            │
q39: ───H───M──────────────
            │
q40: ───I───M──────────────
            │
q41: ───I───M──────────────
            │
q42: ───I───M──────────────
            │
q43: ───H───M──────────────
            │
q44: ───H───M──────────────
            │
q45: ───I───M──────────────
            │
q46: ───H───M──────────────
            │
q47: ───I───M──────────────
            │
q48: ───H───M──────────────
            │
q49: ───H───M──────────────
            │
q50: ───H───M──────────────
            │
q51: ───H───M──────────────
            │
q52: ───I───M──────────────
            │
q53: ───I───M──────────────
            │
q54: ───H───M──────────────
            │
q55: ───I───M──────────────
            │
q56: ───I───M──────────────
            │
q57: ───H───M──────────────
            │
q58: ───H───M──────────────
            │
q59: ───I───M──────────────
            │
q60: ───I───M──────────────
            │
q61: ───I───M──────────────
            │
q62: ───H───M──────────────
            │
q63: ───H───M──────────────
            │
q64: ───H───M──────────────
            │
q65: ───I───M──────────────
            │
q66: ───H───M──────────────
            │
q67: ───I───M──────────────
            │
q68: ───H───M──────────────
            │
q69: ───H───M──────────────
            │
q70: ───I───M──────────────
            │
q71: ───I───M──────────────
            │
q72: ───H───M──────────────
            │
q73: ───H───M──────────────
            │
q74: ───H───M──────────────
            │
q75: ───H───M──────────────
            │
q76: ───I───M──────────────
            │
q77: ───H───M──────────────
            │
q78: ───I───M──────────────
            │
q79: ───H───M──────────────
            │
q80: ───I───M──────────────
            │
q81: ───I───M──────────────
            │
q82: ───I───M──────────────
            │
q83: ───H───M──────────────
            │
q84: ───I───M──────────────
            │
q85: ───I───M──────────────
            │
q86: ───H───M──────────────
            │
q87: ───I───M──────────────
            │
q88: ───I───M──────────────
            │
q89: ───H───M──────────────
            │
q90: ───H───M──────────────
            │
q91: ───I───M──────────────
            │
q92: ───H───M──────────────
            │
q93: ───H───M──────────────
            │
q94: ───H───M──────────────
            │
q95: ───I───M──────────────
            │
q96: ───I───M──────────────
            │
q97: ───I───M──────────────
            │
q98: ───H───M──────────────
            │
q99: ───H───M──────────────


Bob's inital key:  [0 0 1 1 0 0 0 0 0 1 0 1 1 1 1 0 1 0 0 0 0 0 1 1 1 1 1 0 1 0 1 0 1 0 0 1 1
 1 1 1 1 1 1 0 1 1 0 1 1 0 0 1 1 1 0 0 0 1 0 0 1 1 1 0 0 1 1 1 0 1 0 1 1 1
 0 0 1 0 1 1 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 1 1 0 0 0]

Phase 3: Alice and Bob Compare

After Alice and Bob publicly share their basis information, Alice can remove the unmatched basis and compare their final keys to detect any interference, particularly from Eve.

• Removing Unmatched Basis:

  • Alice and Bob publicly compare their measurement bases (alice_bases and bob_bases).
  • Only the qubits measured in the same basis by both Alice and Bob (alice_bases[bit] == bob_bases[bit]) are considered for their final keys (final_alice_key and final_bob_key).

• Comparison to Detect Interference:

  • After forming final_alice_key and final_bob_key, Alice and Bob compare the initial half of their keys to detect any discrepancies caused by Eve's potential interception.
  • If the initial segments match, Alice and Bob proceed to use the remaining bits (final_alice_key and final_bob_key) as their shared secret key.
  • If there is a mismatch in the initial segments, it indicates Eve's interference, prompting Alice and Bob to consider alternative security measures.

final_alice_key = []
final_bob_key = []
final_eve_key = []

for bit in range (num_bits):
    
    if(alice_bases[bit] == bob_bases[bit]):
        final_alice_key.append(alice_key[bit])
        final_bob_key.append(bob_key[bit])
        final_eve_key.append(bob_key[bit])
        
print("Final Alice\'s Key : ", final_alice_key)
print("\nFinal Bob\'s Key : ", final_bob_key)
print("\nFinal Eve\'s Key : ", final_eve_key)

Final Alice's Key :  [1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1]

Final Bob's Key :  [0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]

Final Eve's Key :  [0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]

num_bits_to_compare = int(len(final_alice_key) * 0.5)


if(final_alice_key[0:num_bits_to_compare] == final_bob_key[0:num_bits_to_compare]):
    final_alice_key = final_bob_key[num_bits_to_compare:]
    final_bob_key = final_bob_key[num_bits_to_compare:]
    final_eve_key = final_bob_key[num_bits_to_compare:]
    
    print("\n\n We can use our keys!\n")
    print("Alice\'s Key: ", final_alice_key)
    print("Bob\'s Key: ", final_bob_key)

else:
    print("\n\nEve was lisening. We need to use a different channel!")

Eve was lisening. We need to use a different channel!

Conclusion

The BB84 quantum key distribution protocol ensures security against eavesdropping attempts through several key mechanisms:

• Quantum Properties: The protocol leverages the principles of quantum mechanics, where measuring a quantum state irreversibly disturbs it. Any attempt by Eve to intercept and measure the qubits sent by Alice introduces errors that can be detected by Alice and Bob.

• Random Basis Selection: Alice and Bob randomly select measurement bases (either rectilinear or diagonal), ensuring that Eve cannot reliably predict how to intercept and measure the qubits without introducing errors.

• Public Comparison: After sending the qubits, Alice and Bob publicly compare their chosen measurement bases. This allows them to discard qubits measured in different bases, ensuring that their final shared key (final_alice_key and final_bob_key) is derived only from qubits that were measured identically by both parties.

• Error Detection: Alice and Bob can detect Eve's presence by comparing a subset of their keys. If Eve attempts to intercept and resend qubits, the error rate in their final key will exceed a threshold, indicating a potential eavesdropping attempt.

• Secure Communication: By following these steps, Alice and Bob can securely establish a shared secret key that is immune to eavesdropping attempts. The protocol's reliance on quantum uncertainty and random basis selection ensures that any attempt by Eve to gain information about the key introduces detectable errors, maintaining the security and confidentiality of their communication.

In conclusion, the BB84 protocol's robust design ensures that no matter how Eve tries to intercept or manipulate the qubits, Alice and Bob can detect her presence and maintain the integrity and secrecy of their communication channel.

2.3 Quantum Teleportation Protocol

Quantum Teleportation

Quantum teleportation enables the transfer of an unknown quantum state using two classical bits, without physically sending the quantum particle itself, through entanglement and classical communication.

How Quantum Teleportation Works

1. Entanglement Creation:

   • Two qubits, typically referred to as Alice's qubit and Bob's qubit, are entangled. This means their states are correlated in such a way that the state of one qubit instantly influences the state of the other, regardless of the distance between them.

2. State Preparation:

   • The qubit whose state is to be teleported (let's call it the "target qubit") is prepared in the desired state. This is the state we want to transfer to Bob's qubit.

3. Bell State Measurement:

   • Alice performs a joint measurement on her qubit and the target qubit. This measurement projects the qubits into one of the Bell states (maximally entangled states), and its outcome is used to determine the necessary corrections.

4. Classical Communication:

   • The result of Alice's measurement is sent to Bob through a classical communication channel. This is essential because, due to the nature of quantum mechanics, Bob cannot infer the correct state solely from the quantum channel.

5. State Correction:

   • Bob uses the classical information received from Alice to apply appropriate quantum gates to his qubit, ensuring it now replicates the state of the target qubit. Depending on Alice's measurement result, he might apply specific gates like Pauli X or Z.

Key Points

• No Faster-Than-Light Communication: Quantum teleportation does not allow for faster-than-light communication because the classical communication of measurement results is necessary.

• Quantum Entanglement: The process relies on pre-shared entanglement, making the initial setup crucial for successful teleportation.

• State Destruction: The original state of the target qubit is destroyed during the teleportation process, as dictated by the no-cloning theorem in quantum mechanics.

Quantum teleportation enables the transfer of an unknown quantum state between distant parties using entanglement and classical communication. It leverages the unique properties of quantum entanglement and measurement to achieve this transfer, demonstrating the power and potential of quantum communication and information processing.

NOTE : If you want to see the easy version of Quantum Teleportation go to the lesson 2.7 Part 1.2

import matplotlib.pyplot as plt
import numpy as np
from numpy import pi, random

import cirq


def binary_labels(num_qubits):
    return [bin(x)[2:].zfill(num_qubits) for x in range (2**num_qubits)]

plt.rcParams.update({'font.size': 8})

Part 1: Creating the Quantum Teleportation Protocol

Step 1.1: Define Qubits

• For Alice's qubit (A), Bob's qubit (B), and the qubit to be teleported (Q)

qubit = cirq.NamedQubit('Q')
ebit0 = cirq.NamedQubit('A')
ebit1 = cirq.NamedQubit('B')

Step 1.2: Create the Quantum Circuit and Prepare the Entangled Pair

In this step, we create a quantum circuit and prepare the entangled pair of qubits that will be used for teleportation. The process involves the following operations:

1. Create a Quantum Circuit: We initialize a new cirq.Circuit object to hold our quantum operations.

2. Apply Hadamard Gate: We apply a Hadamard gate to the first qubit (ebit0). This gate puts ebit0 into a superposition state, which is a crucial step for creating entanglement.

3. Apply CNOT Gate: We then apply a CNOT (Controlled-NOT) gate with ebit0 as the control qubit and the second qubit (ebit1) as the target qubit. This operation entangles ebit0 and ebit1, setting up the entangled pair needed for the teleportation protocol.

# Create a circuit
protocol = cirq.Circuit()

# Prepare entangled pair
protocol.append(cirq.H(ebit0))           # Put ebit0 into superposition
protocol.append(cirq.CNOT(ebit0, ebit1)) # Entangle ebit0 and ebit1

protocol

A: ───H───@───
          │
B: ───────X───

Step 1.3: Alice's Operations

In this step, Alice performs operations on her qubit and the qubit to be teleported. The operations are as follows:

1. Apply CNOT Gate: Alice applies a CNOT gate between the qubit to be teleported (Q) and her entangled qubit (ebit0). The qubit Q is the control, and ebit0 is the target. This operation entangles the qubit Q with ebit0.

2. Apply Hadamard Gate: Alice then applies a Hadamard gate to the qubit Q. This operation puts Q into a superposition state, preparing it for measurement in the quantum teleportation protocol.

These operations are crucial for the quantum teleportation process, as they set up the necessary conditions for measuring the qubits and transmitting the quantum state.

# Alice's operations
protocol.append(cirq.CNOT(qubit, ebit0)) # Entangle qubit with ebit0
protocol.append(cirq.H(qubit))           # Prepare qubit for measurement

protocol

A: ───H───@───X───────
          │   │
B: ───────X───┼───────
              │
Q: ───────────@───H───

Step 1.4: Measure Alice's Qubits

In this step, Alice measures her qubits and stores the results in classical registers. This information is crucial for Bob to reconstruct the original state of the qubit being teleported. The steps involved are:

1. Measure ebit0: Alice measures her entangled qubit (ebit0) and stores the result in a classical register labeled 'a'. This measurement collapses the entangled state and provides the first piece of information needed for teleportation.

2. Measure Qubit: Alice measures the qubit to be teleported (Q) and stores the result in a classical register labeled 'b'. This measurement provides the second piece of information required for Bob to perform his corrections.

The measurement results are essential for completing the quantum teleportation protocol, as they will be used to inform Bob's conditional operations.

# Measure Alice's qubits
protocol.append(cirq.measure(ebit0, key='a'))
protocol.append(cirq.measure(qubit, key='b'))

protocol

A: ───H───@───X───M('a')────────────
          │   │
B: ───────X───┼─────────────────────
              │
Q: ───────────@───H────────M('b')───

1.5 Bob's Conditional Operations

In this step, Bob applies conditional operations to his qubit based on the measurement results he receives from Alice. These operations correct the state of his qubit to match the original state of the qubit that Alice teleported. The process involves:

1. Conditional X Gate: Bob applies an X gate to his qubit (ebit1) if the classical measurement result of ebit0 is 1. This operation corrects the bit flip that may have occurred during teleportation.

2. Conditional Z Gate: Bob applies a Z gate to his qubit (ebit1) if the classical measurement result of Q is 1. This operation corrects the phase flip that may have occurred during teleportation.

These conditional operations ensure that Bob's qubit accurately reflects the original state of the qubit that Alice intended to teleport.

# Bob's conditional operations based on Alice's measurements
protocol.append(cirq.X(ebit1).with_classical_controls('a'))  # Apply X gate if 'a' is 1
protocol.append(cirq.Z(ebit1).with_classical_controls('b'))  # Apply Z gate if 'b' is 1

protocol

                  ┌──┐   ┌──┐
A: ───H───@───X─────M───────────────
          │   │     ║
B: ───────X───┼─────╫──────X────Z───
              │     ║      ║    ║
Q: ───────────@────H╫─────M╫────╫───
                    ║     ║║    ║
a: ═════════════════@═════╬^════╬═══
                          ║     ║
b: ═══════════════════════@═════^═══
                  └──┘   └──┘

Step 1.6: Display the Quantum Teleportation Protocol

In this step, we display the quantum teleportation protocol using Cirq's circuit visualization capabilities. This allows us to see the sequence of operations applied to the qubits.

NOTE : we display the quantum teleportation protocol using Cirq's SVGCircuit, which provides a clear visual representation of the circuit.

Warning??? Ignore the findfont: Font family 'Arial' not found error.

import cirq.contrib.svg as svg

# Display the circuit
print("Quantum Teleportation Protocol Circuit:")
print(protocol)

# Display the circuit using SVGCircuit
svg_circuit = svg.SVGCircuit(protocol)
display(svg_circuit)

findfont: Font family 'Arial' not found.

Quantum Teleportation Protocol Circuit:
                  ┌──┐   ┌──┐
A: ───H───@───X─────M───────────────
          │   │     ║
B: ───────X───┼─────╫──────X────Z───
              │     ║      ║    ║
Q: ───────────@────H╫─────M╫────╫───
                    ║     ║║    ║
a: ═════════════════@═════╬^════╬═══
                          ║     ║
b: ═══════════════════════@═════^═══
                  └──┘   └──┘

findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.
findfont: Font family 'Arial' not found.

Part 2: Define a Random $U$ Gate with Random Parameters

The Role of the Random $U$ Gate in Quantum Teleportation

The random unitary gate ($U$ gate) is an essential component in this quantum teleportation demonstration for several reasons:

1. Creating an Arbitrary Quantum State:

   • The objective of quantum teleportation is to transfer an arbitrary quantum state from one qubit (Alice's) to another (Bob's) without physically moving the qubit itself.
   • The random unitary gate is applied to the initial $|0\rangle$ state of qubit $Q$ to transform it into a random quantum state. This simulates a scenario where the state to be teleported is unknown and could be any valid quantum state.

2. Testing the Protocol's Functionality:

   • By using a randomly generated unitary transformation, the teleportation protocol is tested against a wide range of possible states, ensuring its capability to handle any quantum state.
   • This adds robustness to the test, as the random gate can produce diverse states, challenging the teleportation process to correctly manage and transfer these states.

3. Verification of Teleportation:

   • After executing the teleportation protocol, the inverse of the random unitary gate is applied to Bob's qubit to verify the teleportation's accuracy.
   • If the teleportation is successful, the inverse transformation should return Bob's qubit to the $|0\rangle$ state, effectively reversing the initial transformation. Measuring the qubit should confirm this return to $|0\rangle$ , validating the teleportation process.

In summary, the random unitary gate is critical for creating a diverse range of test states and verifying the teleportation protocol's ability to accurately transfer arbitrary quantum states.

Step 2.1: Create Function to Generate Random Gate Matrix

In this step, we define a function to generate the matrix representation of a unitary gate using the random parameters $\theta$, $\phi$, and $\lambda$. This matrix specifies how the unitary gate transforms a quantum state.

Background: A single-qubit unitary matrix can be parameterized using three angles: $\theta$, $\phi$, and $\lambda$. This general form allows for a wide range of transformations that can be applied to a qubit:

$$ U(\theta, \phi, \lambda) = \begin{pmatrix} \cos\left(\frac{\theta}{2}\right) & -e^{i \lambda} \sin\left(\frac{\theta}{2}\right) \\ e^{i \phi} \sin\left(\frac{\theta}{2}\right) & e^{i (\phi + \lambda)} \cos\left(\frac{\theta}{2}\right) \end{pmatrix} $$

How to Use This Formula:

1. Parameter Generation:

   • Randomly generate the values for $\theta$, $\phi$, and $\lambda$, each within the range of $0$ to $2\pi$. These parameters define the specific transformation applied by the gate.

2. Matrix Construction:

   • The matrix is constructed using these parameters:
     • $\cos\left(\frac{\theta}{2}\right)$ and $\sin\left(\frac{\theta}{2}\right)$ determine the amplitude adjustments.
     • The exponential terms $e^{i \lambda}$ and $e^{i \phi}$ introduce phase shifts, critical for capturing the unitary's effect.

3. Matrix Representation:

   • The function random_unitary_gate_matrix uses these parameters to compute and return the matrix as a NumPy array, making it suitable for integration into a quantum circuit.

# Define the matrix for the unitary gate using the random parameters
def random_unitary_gate_matrix(theta, phi, lam):
    return np.array([
        [np.cos(theta / 2), -np.exp(1j * lam) * np.sin(theta / 2)],
        [np.exp(1j * phi) * np.sin(theta / 2), np.exp(1j * (phi + lam)) * np.cos(theta / 2)]
    ])

Step 2.2: Define Parameters and Create the Random Gate

In this step, we define the random parameters for the unitary gate and create its matrix representation. This matrix demonstrates the transformation applied by the gate to a quantum state.

Process:

1. Define Random Parameters:

   • Generate random values for $\theta$, $\phi$, and $\lambda$ within the range $0$ to $2\pi$. These parameters determine the specific characteristics of the unitary transformation.

2. Create the Random Gate Matrix:

   • Compute the matrix representation of the unitary gate using the random_unitary_gate_matrix function with the generated parameters. This matrix describes how the gate modifies the amplitude and phase of a qubit.

3. Create the MatrixGate:

   • Convert the matrix into a Cirq MatrixGate using cirq.MatrixGate(random_gate_matrix). This allows us to apply the gate in a Cirq quantum circuit.

4. Display the Matrix:

   • Print the matrix to visualize the unitary gate's transformation properties. This step helps in understanding the effects of the random unitary operation on a quantum state.

# Define random parameters
theta = random.random() * 2 * pi
phi = random.random() * 2 * pi
lam = random.random() * 2 * pi

# Create the random gate matrix and then create random gate
random_gate_matrix = random_unitary_gate_matrix(theta, phi, lam)
random_gate = cirq.MatrixGate(random_gate_matrix)

# Display the matrix representation of the random gate
print("Matrix representation of the random gate:\n")
print(random_gate_matrix)

Matrix representation of the random gate:

[[-0.9085763 +0.j          0.36338968+0.20600254j]
 [ 0.37240587+0.18921675j  0.50169727+0.75750297j]]

Part 3: Testing the Teleportation Protocol

• In this part, we test the teleportation protocol to ensure it correctly transfers a quantum state from Alice to Bob. We achieve this by applying a randomly generated single-qubit gate to a qubit and then teleporting the state.

Step 3.1: Apply the Random Gate to the Initial State

• We initialize a new quantum circuit including the qubits and classical registers used in the teleportation protocol. We then apply the randomly selected unitary gate to qubit $Q$, transforming its initial state $|0\rangle$ into a random quantum state. This setup allows us to simulate the teleportation of a non-trivial state.

# Define qubits
qubit = cirq.NamedQubit('Q')   # Qubit to be teleported
ebit0 = cirq.NamedQubit('A')   # Alice's entangled qubit 0
ebit1 = cirq.NamedQubit('B')   # Alice's entangled qubit 1

# Create a new circuit
test = cirq.Circuit()

# Apply the randomly selected gate to qubit Q
test.append(random_gate.on(qubit))  # Apply the random UGate to qubit Q

test

      ┌                           ┐
Q: ───│-0.909+0.j     0.363+0.206j│───
      │ 0.372+0.189j  0.502+0.758j│
      └                           ┘

Step 3.2: Append the Teleportation Protocol

In this step, we integrate the previously defined teleportation protocol into the circuit. This incorporates all necessary operations for quantum teleportation, including entanglement, gate operations, and measurements.

Process:

• Use the append method to add the teleportation protocol to the circuit created in the previous step. This step ensures that the full teleportation process is included in the circuit setup.

# Append the entire teleportation protocol from above
test.append(protocol)   # Add the previously defined teleportation protocol to the current circuit

test

                                                  ┌──┐   ┌──┐
A: ───────────────────────────────────H───@───X─────M───────────────
                                          │   │     ║
B: ───────────────────────────────────────X───┼─────╫──────X────Z───
                                              │     ║      ║    ║
      ┌                           ┐           │     ║      ║    ║
Q: ───│-0.909+0.j     0.363+0.206j│───────────@────H╫─────M╫────╫───
      │ 0.372+0.189j  0.502+0.758j│                 ║     ║║    ║
      └                           ┘                 ║     ║║    ║
                                                    ║     ║║    ║
a: ═════════════════════════════════════════════════@═════╬^════╬═══
                                                          ║     ║
b: ═══════════════════════════════════════════════════════@═════^═══
                                                  └──┘   └──┘

Step 3.3: Apply the Inverse of the Random Gate and Measure

In this step, we apply the inverse (i.e., conjugate transpose) of the random gate to qubit $B$. By measuring qubit $B$, we can verify the correctness of the teleportation process if it returns to the $|0\rangle$ state.

# Create the inverse gate
inverse_matrix = np.linalg.inv(random_gate_matrix)
inverse_gate = cirq.MatrixGate(inverse_matrix)

# Apply the inverse of the random unitary to qubit B
test.append(inverse_gate.on(ebit1))

# Measure the state of qubit B and store the result
test.append(cirq.measure(ebit1, key='Result'))

Step 3.4: Display the Circuit

• To visualize the test circuit, we display the entire setup, including the application of the random gate, the teleportation protocol, and the inverse gate.

# Display the circuit
print("Final Circuit:\n")
print(test)

Final Circuit:

                                                  ┌──┐   ┌──┐
A: ───────────────────────────────────H───@───X─────M─────────────────────────────────────────────────────────────
                                          │   │     ║
                                          │   │     ║               ┌                           ┐
B: ───────────────────────────────────────X───┼─────╫──────X────Z───│-0.909+0.j     0.372-0.189j│───M('Result')───
                                              │     ║      ║    ║   │ 0.363-0.206j  0.502-0.758j│
                                              │     ║      ║    ║   └                           ┘
                                              │     ║      ║    ║
      ┌                           ┐           │     ║      ║    ║
Q: ───│-0.909+0.j     0.363+0.206j│───────────@────H╫─────M╫────╫─────────────────────────────────────────────────
      │ 0.372+0.189j  0.502+0.758j│                 ║     ║║    ║
      └                           ┘                 ║     ║║    ║
                                                    ║     ║║    ║
a: ═════════════════════════════════════════════════@═════╬^════╬═════════════════════════════════════════════════
                                                          ║     ║
b: ═══════════════════════════════════════════════════════@═════^═════════════════════════════════════════════════
                                                  └──┘   └──┘

Part 4: Run the Simulation and Analyze Results

In this part, we use Cirq's simulator to run the quantum circuit and analyze the results by plotting histograms of the measurement outcomes. We will see the statistics for the classical bits, focusing on whether the teleportation was successful.

Process:

1. Create a Simulator Instance:

   • Initialize a Cirq simulator to run the quantum circuit.

2. Run the Quantum Circuit:

   • Execute the quantum circuit with 1000 repetitions to gather sufficient measurement data.

3. Plot the Histogram:

   • Generate a histogram of the measurement outcomes to visualize the distribution of results.

# Create a simulator instance
simulator = cirq.Simulator()

# Run the quantum circuit on the simulator and get the result
result = simulator.run(test, repetitions=1000)  # Run the circuit with 1000 repetitions

# Plot the histogram of the measurement outcomes
hist = cirq.plot_state_histogram(result, plt.subplot(), title='Measurement Outcomes', xlabel='States', ylabel='Occurrences', tick_label=binary_labels(3))

plt.show()

Result Analysis of Quantum Teleportation Protocol

The quantum teleportation protocol was implemented and simulated to verify its correctness. Here’s a detailed analysis of the results obtained from the simulation:

1. Circuit Overview:

   • The quantum circuit consists of preparing an entangled pair of qubits $A$ and $B$, performing operations on qubit $Q$ (the one to be teleported), measuring the qubits, and applying conditional operations based on the measurement results.

2. Measurement Results:

   • The histogram of measurement outcomes from the final circuit is analyzed to determine the success of the teleportation.

3. Expected Outcomes:

   • In the final measurement, the states where the last qubit is 0 should ideally have non-zero counts. This is because qubit $B$ is supposed to match the state of qubit $Q$ after teleportation, and any discrepancies would manifest as deviations in these outcomes.
   • The states 001, 011, 101, and 111 should ideally have zero counts. This indicates that the final state of qubit $B$ is consistent with the teleported state and that the effect of the random unitary gate has been correctly reversed.

4. Interpreting the Histogram:

   • The histogram shows that the states where the last qubit is 0 (i.e., 000, 010, 100, 110) have non-zero counts. This result confirms that the teleportation protocol has successfully transferred the state from qubit $Q$ to qubit $B$.
   • The absence of states 001, 011, 101, and 111 supports the correctness of the teleportation, indicating that the quantum state was accurately teleported and reconstructed on qubit $B$.

In summary, the measurement outcomes align with the expected results, demonstrating that the quantum teleportation protocol was executed successfully and the qubit state was correctly teleported.

2.4 Superdense Coding Protocol

Superdense Coding

Superdense coding is a quantum communication protocol that enables the transmission of two classical bits of information using only one qubit. This protocol leverages the properties of quantum entanglement to achieve a more efficient use of quantum resources.

How Superdense Coding Works

1. Entanglement Creation:

   • Alice and Bob share a pair of entangled qubits, typically prepared in a Bell state (one of the four maximally entangled states). This entanglement serves as the key resource for the protocol.

2. State Encoding:

   • Alice wishes to send two classical bits to Bob. To accomplish this, she encodes these bits into her qubit by applying one of four quantum gates (Pauli X, Pauli Z, Pauli XZ, or the identity operation) to her qubit. Each gate corresponds to one of the four possible classical messages: 00, 01, 10, or 11.

3. Sending the Qubit:

   • Alice then sends her qubit to Bob. The qubit that Alice transmits, combined with Bob's entangled qubit, forms a new joint quantum state.

4. Decoding the Message:

   • Upon receiving Alice's qubit, Bob performs a joint measurement on both qubits (the one he originally had and the one he received from Alice). This measurement decodes the classical information from the combined state, allowing Bob to retrieve the two classical bits that Alice encoded.

Key Points

• Efficiency: Superdense coding allows for the transmission of two classical bits using only one qubit, effectively doubling the capacity of a quantum communication channel compared to classical methods.

• Entanglement Resource: The success of the protocol relies on the initial entanglement shared between Alice and Bob. Proper entanglement preparation is crucial for accurate information transfer.

• Classical Information: After performing the measurement, Bob can perfectly reconstruct the two classical bits that Alice intended to send.

• Quantum Measurement: Bob's measurement involves a Bell-state measurement, which distinguishes between the four possible quantum states created by Alice's encoding.

Superdense coding illustrates the power of quantum entanglement in enhancing communication efficiency. By using quantum resources to transmit classical information, it showcases the unique advantages offered by quantum technologies over classical systems.

import cirq
import numpy as np
from numpy import pi, random
import matplotlib.pyplot as plt

def binary_labels(num_qubits):
    return [bin(x)[2:].zfill(num_qubits) for x in range (2**num_qubits)]

plt.rcParams.update({'font.size': 8})

Step 1: Define Quantum and Classical Registers

• rbg (Randomizer Qubit): Used to generate random bits for Alice.
• ebit0 and ebit1 (Entangled Qubits): Form the entangled pair between Alice and Bob. ebit0 is with Alice, and ebit1 is with Bob.

# Define qubits
rbg = cirq.NamedQubit('randomizer')  # Quantum register for the random bit generator
ebit0 = cirq.NamedQubit('A')         # Qubit 'A' as part of the entangled pair (ebit) shared with Bob
ebit1 = cirq.NamedQubit('B')         # Qubit 'B' as part of the entangled pair (ebit) shared with Alice

Step 2: Prepare Entangled Qubits

• Hadamard Gate on ebit0: Creates a superposition state on qubit ebit0. The Hadamard gate transforms the state $0\rangle$ to $ \frac{1}{\sqrt{2}}(|0\rangle + |1\rangle) $.

• CNOT Gate: Entangles ebit0 with ebit1.

# Create a circuit
test = cirq.Circuit()

# Initialize the entangled bit (ebit)
test.append(cirq.H(ebit0))            # Apply Hadamard gate to qubit 'A' to create superposition
test.append(cirq.CNOT(ebit0, ebit1))  # Apply CNOT gate to entangle qubit 'A' (control) with qubit 'B' (target)

test

A: ───H───@───
          │
B: ───────X───

Step 3: Generate Alice's Bits c and d

• Hadamard Gates and Measurements on rbg: These operations generate two random classical bits, c and d, which will dictate Alice's subsequent actions. Applying Hadamard gates to the rbg qubit creates a superposition, and measuring the rbg qubit after these gates yields random bit values. These measurements are stored in the classical registers Alice_c and Alice_d.

# Use the 'randomizer' qubit to generate Alice's bits c and d
test.append(cirq.H(rbg))              # Apply Hadamard gate to the 'randomizer' qubit to create superposition (generate random bit for 'c')
test.append(cirq.measure(rbg, key='Alice_c'))  # Measure the 'randomizer' qubit and store the result in 'Alice_c'
test.append(cirq.H(rbg))              # Apply Hadamard gate again to the 'randomizer' qubit (generate random bit for 'd')
test.append(cirq.measure(rbg, key='Alice_d'))  # Measure the 'randomizer' qubit and store the result in 'Alice_d'

test

A: ────────────H───@─────────────────────────────────
                   │
B: ────────────────X─────────────────────────────────

randomizer: ───H───M('Alice_c')───H───M('Alice_d')───

Step 4: Alice's Actions Based on Her Bits

• Conditional X Gate: Applied to ebit0 if Alice's bit c is 1. This operation flips the state of ebit0 from $|0\rangle$ to $|1\rangle$ or vice versa.

• Conditional Z Gate: Applied to ebit0 if Alice's bit d is 1. This introduces a phase flip (Z gate) on ebit0, changing the phase of the state.

# Apply the gates based on Alice's bits
test.append(cirq.X(ebit0).with_classical_controls('Alice_c'))  # Apply X gate if 'Alice_c' is 1
test.append(cirq.Z(ebit0).with_classical_controls('Alice_d'))  # Apply Z gate if 'Alice_d' is 1

test

                       ┌──┐
A: ────────────H───@─────X────────Z───
                   │     ║        ║
B: ────────────────X─────╫────────╫───
                         ║        ║
randomizer: ───H───M────H╫────M───╫───
                   ║     ║    ║   ║
Alice_c: ══════════@═════^════╬═══╬═══
                              ║   ║
Alice_d: ═════════════════════@═══^═══
                       └──┘

Step 5: Bob's Actions

• CNOT Gate: Applied to ebit0 (Alice's qubit) and ebit1 (Bob's qubit) to disentangle the qubits, transferring the encoded information from ebit0 to ebit1.

• Hadamard Gate on ebit0: Transforms the state of ebit0 to reveal the encoded information. This is necessary to complete the decoding process, allowing Bob to measure the final state correctly.

# Bob's actions
test.append(cirq.CNOT(ebit0, ebit1))  # Apply CNOT gate with qubit 'A' as control and qubit 'B' as target to disentangle
test.append(cirq.H(ebit0))            # Apply Hadamard gate to qubit 'A' to complete the decoding process

test

                       ┌──┐
A: ────────────H───@─────X────────Z───@───H───
                   │     ║        ║   │
B: ────────────────X─────╫────────╫───X───────
                         ║        ║
randomizer: ───H───M────H╫────M───╫───────────
                   ║     ║    ║   ║
Alice_c: ══════════@═════^════╬═══╬═══════════
                              ║   ║
Alice_d: ═════════════════════@═══^═══════════
                       └──┘

Step 6: Store Bob's Measurements

• Measurements: Bob measures the entangled qubits ebit0 and ebit1. The results of these measurements are stored in Bob's classical registers Bob_d and Bob_c, which should match Alice's original bits c and d.

# Bob's measurement
test.append(cirq.measure(ebit0, key='Bob_d'))  # Measure qubit 'A' and store the result in Bob's 'd' classical register
test.append(cirq.measure(ebit1, key='Bob_c'))  # Measure qubit 'B' and store the result in Bob's 'c' classical register

test

                       ┌──┐
A: ────────────H───@─────X────────Z───@───H────────────M('Bob_d')───
                   │     ║        ║   │
B: ────────────────X─────╫────────╫───X───M('Bob_c')────────────────
                         ║        ║
randomizer: ───H───M────H╫────M───╫─────────────────────────────────
                   ║     ║    ║   ║
Alice_c: ══════════@═════^════╬═══╬═════════════════════════════════
                              ║   ║
Alice_d: ═════════════════════@═══^═════════════════════════════════
                       └──┘

Step 7: Display and Run the Circuit

• Circuit Diagram: Displays the visual representation of the quantum circuit.
• Simulation: Runs the circuit multiple times (1000 repetitions) to collect statistics on the measurement outcomes.
• Histogram: Shows the distribution of measurement results, demonstrating whether Bob's results agree with Alice's original bits.

# Display the quantum circuit diagram
print("Quantum Circuit Diagram:")
print(test)

# Create a simulator instance
simulator = cirq.Simulator()

# Run the quantum circuit on the simulator and get the result
result = simulator.run(test, repetitions=1000)  # Run the circuit with 1000 repetitions

# Plot the histogram of the measurement outcomes
hist = cirq.plot_state_histogram(result, plt.subplot(), title='Measurement Outcomes', xlabel='States', ylabel='Occurrences', tick_label=binary_labels(4))

plt.show()

Quantum Circuit Diagram:
                       ┌──┐
A: ────────────H───@─────X────────Z───@───H────────────M('Bob_d')───
                   │     ║        ║   │
B: ────────────────X─────╫────────╫───X───M('Bob_c')────────────────
                         ║        ║
randomizer: ───H───M────H╫────M───╫─────────────────────────────────
                   ║     ║    ║   ║
Alice_c: ══════════@═════^════╬═══╬═════════════════════════════════
                              ║   ║
Alice_d: ═════════════════════@═══^═════════════════════════════════
                       └──┘

Discussion on the Superdense Coding Protocol Results

The successful implementation of the superdense coding protocol is demonstrated by the measurement results, where the states with non-zero values are 0000, 0101, 1010, and 1111. This result confirms that Alice and Bob's classical bits always agree, as intended by the protocol. Here’s a detailed discussion on the outcome:

Protocol Recap

1. Entanglement Preparation: Alice and Bob start with an entangled pair of qubits. This entanglement is achieved by applying a Hadamard gate to ebit0 followed by a CNOT gate, creating a Bell state between ebit0 (Alice's qubit) and ebit1 (Bob's qubit).

2. Random Bit Generation: Alice generates two classical bits c and d by measuring a third qubit (rbg) after applying Hadamard gates. These bits determine the operations Alice will perform on her qubit.

3. Alice's Actions: Based on the values of c and d, Alice applies conditional gates (X and Z) to ebit0. These gates encode Alice’s bits into the entangled state.

4. Transmission and Bob's Decoding: Alice sends her qubit to Bob, who then performs operations to decode the information. Bob applies a CNOT gate followed by a Hadamard gate to extract the encoded bits from the entangled state.

5. Measurement: Bob measures the qubits and records the results in his classical registers.

Results Analysis

The non-zero states observed in the histogram are 0000, 0101, 1010, and 1111. Here's the detailed analysis of these results:

• State 0000: This indicates that Alice’s bits were 00 and Bob’s bits were 00. This state occurs when neither X nor Z gates are applied by Alice.

• State 0101: This indicates that Alice’s bits were 01 and Bob’s bits were 01. Alice applied only the Z gate, introducing a phase flip.

• State 1010: This state corresponds to Alice’s bits 10 and Bob’s bits 10. Alice applied only the X gate, flipping the state of her qubit.

• State 1111: This indicates that Alice’s bits were 11 and Bob’s bits were 11. Alice applied both the X and Z gates, resulting in both state and phase flips.

Conclusion

The successful transmission and agreement of classical bits between Alice and Bob validate the superdense coding protocol. The fact that the states are consistent and aligned as 0000, 0101, 1010, and 1111 confirms that Alice’s encoded bits are correctly received by Bob. This result demonstrates that superdense coding allows for the efficient transmission of two classical bits of information using only one qubit, leveraging the power of quantum entanglement and operations.

The histogram shows that the protocol works as expected, and the classical bits Alice sends are accurately decoded by Bob, confirming the successful implementation of the superdense coding protocol.

2.5 Quantum Network

Quantum Network

A Quantum Network is a network of quantum systems where qubits are entangled and quantum information is transmitted using quantum teleportation and entanglement swapping. Building a quantum network involves extending entanglement between distant qubits and facilitating secure communication over large distances. Here’s how these concepts contribute to the development of a quantum network:

Building a Quantum Network with Quantum Teleportation and Entanglement Swapping

1. Quantum Teleportation:

   • Purpose: Quantum teleportation allows the transfer of quantum information between distant qubits using pre-established entanglement and classical communication. It ensures that the state of a qubit can be transmitted across the network without physically moving the qubit itself.
   • Process:
     • Preparation: Alice and Bob share a pair of entangled qubits.
     • Teleportation: Alice performs measurements on her qubit and the qubit to be teleported. The results are sent to Bob via classical communication.
     • Recovery: Based on the measurement results, Bob applies corrective operations to his qubit to recreate the teleported state.

2. Entanglement Swapping:

   • Purpose: Entanglement swapping allows for the creation of entanglement between two qubits that have never interacted directly. This process is crucial for establishing entanglement over long distances and linking multiple segments of the network.
   • Process:
     • Initial Entanglement: Start with entangled pairs and send qubits to a repeater station.
     • Repeater Station: The repeater entangles the qubits received and performs measurements.
     • Entanglement Extension: Based on the measurement results, corrective operations are applied to establish entanglement between distant qubits.

Practical Implementation

1. Network Setup:

   • Entanglement Distribution: Use quantum teleportation and entanglement swapping to create a network of entangled qubits. Establish initial entanglement pairs and use repeaters to extend the entanglement over long distances.

2. Quantum Communication:

   • Secure Communication: Utilize quantum teleportation for secure and instantaneous transmission of quantum information across the network.
   • Error Correction: Implement quantum error correction to maintain the integrity of the information and compensate for losses or errors.

3. Scalability:

   • Repeater Networks: Deploy multiple repeaters to extend the network further and create a global quantum communication infrastructure.
   • Integration: Integrate quantum networks with classical communication networks to enable hybrid systems that leverage both quantum and classical information processing.

Building a quantum network involves using quantum teleportation to transfer quantum information and entanglement swapping to establish entanglement between distant qubits. These techniques facilitate the development of scalable and secure quantum communication systems, paving the way for advancements in quantum computing and distributed quantum information processing.

import matplotlib.pyplot as plt
import numpy as np

import cirq

def binary_labels(num_qubits):
    return [bin(x)[2:].zfill(num_qubits) for x in range (2**num_qubits)]

plt.rcParams.update({'font.size': 8})

Part 1: Preparing Bell States and Quantum Teleportation

Part 1.1: Creating Different Bell States

1.1.1: Creating $\phi^+$ ($B_{00}$) State

The $B_{00}$ state, also known as the $\phi^+$ state, is represented as:

$$ |\phi^+\rangle = \frac{1}{\sqrt{2}}(|00\rangle + |11\rangle) $$

# Create a circuit
circuit = cirq.Circuit()

# Create two qubits
qubits = cirq.NamedQubit.range(2, prefix='q')

# Apply a Hadamard gate to the first qubit
circuit.append(cirq.H(qubits[0]))

# Apply a CNOT gate with the first qubit as control and the second as target
circuit.append(cirq.CNOT(qubits[0], qubits[1]))

# Bell State
bell_state = cirq.final_state_vector(circuit)

# Display the circuit and Bell State
print('Circuit :\n\n',circuit)
print('\nBell State: ', cirq.dirac_notation(bell_state))

Circuit :

 q0: ───H───@───
           │
q1: ───────X───

Bell State:  0.71|00⟩ + 0.71|11⟩

1.1.2: Creating $\phi^-$ ($B_{10}$) State

The $B_{10}$ state, also known as the $\phi^-$ state, is represented as:

$$ |\phi^-\rangle = \frac{1}{\sqrt{2}}(|00\rangle - |11\rangle) $$

# Create a circuit
circuit = cirq.Circuit()

# Create two qubits
qubits = cirq.NamedQubit.range(2, prefix='q')

# Apply a Hadamard gate to the first qubit
circuit.append(cirq.H(qubits[0]))

# Apply a CNOT gate with the first qubit as control and the second as target
circuit.append(cirq.CNOT(qubits[0], qubits[1]))

# Apply a Z gate to the first qubit
circuit.append(cirq.Z(qubits[0]))

# Bell State
bell_state = cirq.final_state_vector(circuit)

# Display the circuit and Bell State
print('Circuit :\n\n',circuit)
print('\nBell State: ', cirq.dirac_notation(bell_state))

Circuit :

 q0: ───H───@───Z───
           │
q1: ───────X───────

Bell State:  0.71|00⟩ - 0.71|11⟩

1.1.3: Creating $\psi^+$ ($B_{01}$) State

The $B_{01}$ state, also known as the $\psi^+$ state, is represented as:

$$ |\psi^+\rangle = \frac{1}{\sqrt{2}}(|01\rangle + |10\rangle) $$

# Create a circuit
circuit = cirq.Circuit()

# Create two qubits
qubits = cirq.NamedQubit.range(2, prefix='q')

# Apply a Hadamard gate to the first qubit
circuit.append(cirq.H(qubits[0]))

# Apply a CNOT gate with the first qubit as control and the second as target
circuit.append(cirq.CNOT(qubits[0], qubits[1]))

# Apply a X gate to the first qubit
circuit.append(cirq.X(qubits[0]))

# Bell State
bell_state = cirq.final_state_vector(circuit)

# Display the circuit and Bell State
print('Circuit :\n\n',circuit)
print('\nBell State: ', cirq.dirac_notation(bell_state))

Circuit :

 q0: ───H───@───X───
           │
q1: ───────X───────

Bell State:  0.71|01⟩ + 0.71|10⟩

1.1.4: Creating $\psi^-$ ($B_{11}$) State

The $B_{11}$ state, also known as the $\psi^-$ state, is represented as:

$$ |\psi^-\rangle = \frac{1}{\sqrt{2}}(|01\rangle - |10\rangle) $$

# Create a circuit
circuit = cirq.Circuit()

# Create two qubits
qubits = cirq.NamedQubit.range(2, prefix='q')

# Apply a Hadamard gate to the first qubit
circuit.append(cirq.H(qubits[0]))

# Apply a CNOT gate with the first qubit as control and the second as target
circuit.append(cirq.CNOT(qubits[0], qubits[1]))

# Apply a X gate then a Z gate to the first qubit
circuit.append(cirq.X(qubits[0]))
circuit.append(cirq.Z(qubits[0]))

# Bell State
bell_state = cirq.final_state_vector(circuit)

# Display the circuit and Bell State
print('Circuit :\n\n',circuit)
print('\nBell State: ', cirq.dirac_notation(bell_state))

Circuit :

 q0: ───H───@───X───Z───
           │
q1: ───────X───────────

Bell State:  0.71|01⟩ - 0.71|10⟩

Part 1.2: Preparing Quantum Teleportation Protocol

Quantum Teleportation is a quantum information protocol that allows the transfer of the state of a qubit from one location to another without physically moving the qubit itself. This process is foundational for quantum communication and quantum computing, as it enables the transmission of quantum information over distances using entanglement and classical communication.

Key Concepts

1. Quantum State: The complete description of a qubit's information, which can be in any superposition of basis states. For example, the state $|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$ represents a general quantum state.

2. Entanglement: A fundamental quantum phenomenon where two or more qubits become correlated in such a way that the state of one qubit instantly influences the state of the other, regardless of distance. In quantum teleportation, a shared entangled pair between the sender and receiver is crucial.

3. Classical Communication: The process of transmitting classical information (such as measurement results) between the sender and receiver. This information is used to perform corrective operations on the receiver's qubit to complete the teleportation process.

Steps in Quantum Teleportation

1. Preparation:

   • Shared Entanglement: Alice and Bob share an entangled pair of qubits. This entangled pair acts as a resource for teleportation.

2. Teleportation Process:

   • State Preparation: Alice prepares a qubit in the state $|\psi\rangle$ that she wants to teleport.
   • Measurement: Alice performs a joint measurement (Bell state measurement) on her qubit and the entangled pair. This measurement collapses the qubit state into one of the Bell states, and the result is sent to Bob.

3. Classical Communication:

   • Sending Results: Alice sends the measurement results to Bob via classical channels. This information is used to determine which corrective operations Bob needs to apply.

4. Correction and Recovery:

   • Bob’s Corrections: Based on Alice's measurement results, Bob applies a set of corrective operations (such as X and Z gates) to his entangled qubit to reconstruct the teleported state.

5. Outcome:

   • Final State: After applying the corrective operations, Bob's qubit now holds the state that Alice originally prepared, effectively completing the teleportation.

Step 1.2.1: Alice and Bob Share a Bell Pair and Go Their Separate Ways

• This step involves one qubit representing the message to be sent, and two qubits for Alice and Bob.
• There is also one classical bit for each measurement.
• We create a Bell state using Alice's and Bob's qubits.

circuit = cirq.Circuit()

# Define qubits
msg = cirq.NamedQubit('Message')
alice = cirq.NamedQubit('Alice')
bob = cirq.NamedQubit('Bob')

# Entangle Alice's and Bob's qubits
circuit.append(cirq.H(alice))
circuit.append(cirq.CNOT(alice, bob))

# Display the circuit
print(circuit)

Alice: ───H───@───
              │
Bob: ─────────X───

Step 1.2.2: Alice Prepares a Special State to Teleport to Bob

• Prepare the teleportation qubit in the $|1\rangle$ state.

circuit.append(cirq.X(msg))

circuit

Alice: ─────H───@───
                │
Bob: ───────────X───

Message: ───X───────

Step 1.2.3: Alice Measures Her Half of the Entangled Pair and Her Special State in the Entangled Basis

• Apply a CNOT gate with the msg qubit as control and alice qubit as the target.
• Apply a Hadamard gate to the msg qubit.
• Measure both msg and alice qubits.

circuit.append(cirq.CNOT(msg, alice))
circuit.append(cirq.H(msg))
circuit.append(cirq.measure(msg, alice))

circuit

Alice: ─────H───@───X───────M───
                │   │       │
Bob: ───────────X───┼───────┼───
                    │       │
Message: ───X───────@───H───M───

Step 1.2.4: Alice Sends Bob Her Measurement Results Over a Classical Channel

• Alice communicates her measurement results to Bob via a classical channel.
• This information is necessary for Bob to perform the appropriate corrections on his qubit to complete the teleportation process.

Step 1.2.5: Bob Adjusts His Half of the Bell Pair Based on Alice's Measurement Results

• Apply an X gate to Bob's qubit if Alice's measurement result is 1 (corresponding to the CNOT gate).
• Apply a Z gate to Bob's qubit if the measurement of the teleported qubit is 1 (corresponding to the CZ gate).
• Measure Bob's qubit to obtain the final state.

circuit.append(cirq.CNOT(alice, bob))
circuit.append(cirq.CZ(msg, bob))

circuit.append(cirq.measure(bob))

print('Final Circuit: \n\n',circuit)

Final Circuit: 

 Alice: ─────H───@───X───────M───@───────────
                │   │       │   │
Bob: ───────────X───┼───────┼───X───@───M───
                    │       │       │
Message: ───X───────@───H───M───────@───────

Step 1.2.6: Simulating Quantum Teleportation

sim = cirq.Simulator()

results = sim.run(circuit, repetitions=100)

hist = cirq.plot_state_histogram(results, plt.subplot(), title= 'Quantum Teleportation', xlabel='Sates', ylabel='Occurrences', tick_label=binary_labels(3))

plt.show()

Results and Explanation

After simulating the quantum teleportation circuit and plotting the histogram of measurement results, you should observe the following:

• Histogram Analysis:

  • The histogram will display the occurrences of different qubit states after running the simulation.
  • Due to the nature of quantum teleportation, the result should show only non-zero counts where the third qubit (the msg qubit) is in the $|1\rangle$ state.

• Why the Results are Correct:

  • In the teleportation protocol, the msg qubit is prepared in the $|1\rangle$ state initially. After teleportation, Bob's qubit should end up in the state that was originally prepared in the msg qubit.
  • Alice's measurements and subsequent operations on Bob's qubit ensure that Bob's qubit accurately represents the state of the msg qubit.
  • The histogram should therefore only have non-zero counts where the measurement result reflects the state of the msg qubit as $|1\rangle$.

• Expected Outcome:

  • Given the setup, the final state of the msg qubit after teleportation will be the state that Bob's qubit is in, which should correspond to the state that was originally prepared.
  • Since the msg qubit was initially set to $|1\rangle$, and assuming perfect teleportation, the histogram should show that the state $|1\rangle$ is observed with high probability.

This result confirms that the quantum teleportation protocol has correctly transferred the state of the msg qubit to Bob's qubit, as expected.

Question: Modified Code to Send $|+\rangle$ State

The goal is to modify the quantum teleportation code to send the $|+\rangle$ state instead of the $|1\rangle$ state.

Modified Circuit Description

• Initial Setup: Entangle Alice's and Bob's qubits.
• Prepare the State: Set the msg qubit to the $|+\rangle$ state.
• Teleportation Process:
  • Perform entanglement and measurement operations.
  • Apply corrections based on Alice's measurements.

# Define the circuit
circuit = cirq.Circuit()

# Define qubits
msg = cirq.NamedQubit('Message')
alice = cirq.NamedQubit('Alice')
bob = cirq.NamedQubit('Bob')

# Entangle Alice's and Bob's qubits
circuit.append(cirq.H(alice))
circuit.append(cirq.CNOT(alice, bob))

# Prepare the |+⟩ state on the msg qubit
circuit.append(cirq.H(msg))                     # Prepare |+⟩ state

# Perform the teleportation protocol
circuit.append(cirq.CNOT(msg, alice))
circuit.append(cirq.H(msg))
circuit.append(cirq.measure(msg, alice))

# Apply corrections based on Alice's measurements
circuit.append(cirq.CNOT(alice, bob))
circuit.append(cirq.CZ(msg, bob))

# Measure Bob's qubit
circuit.append(cirq.measure(bob))

# Print the final circuit
print('Final Circuit: \n\n', circuit)

# Run the simulation
sim = cirq.Simulator()
results = sim.run(circuit, repetitions=100)

# Plot the histogram of the measurement results
hist = cirq.plot_state_histogram(results, plt.subplot(), title='Quantum Teleportation', xlabel='States', ylabel='Occurrences', tick_label=binary_labels(3))

plt.show()

Final Circuit: 

 Alice: ─────H───@───X───────M───@───────────
                │   │       │   │
Bob: ───────────X───┼───────┼───X───@───M───
                    │       │       │
Message: ───H───────@───H───M───────@───────

Explanation of Results

The histogram shows no zero counts because:

• Initial State: The msg qubit is prepared in the $|+\rangle$ state, which is a superposition of $|0\rangle$ and $|1\rangle$.
• Teleportation Protocol: The teleportation protocol transfers the state of the msg qubit to Bob's qubit. Since the msg qubit was initially in the $|+\rangle$ state, this state is teleported to Bob's qubit.
• Measurement Outcomes: In quantum teleportation, the final state of Bob's qubit reflects the initial state of the msg qubit. As a result, the histogram should show counts for states corresponding to the $|+\rangle$ state of the msg qubit.

Given that the $|+\rangle$ state is equally likely to collapse to $|0\rangle$ or $|1\rangle$ upon measurement, we will observe both states with non-zero counts in the histogram, reflecting the superposition nature of the $|+\rangle$ state.

Part 2: Entanglement Swapping

Entanglement Swapping is a quantum information protocol that allows the creation of entanglement between two qubits that have never interacted directly. This process is particularly important in quantum communication and quantum networking, as it enables the extension of entanglement across long distances.

Key Concepts

1. Entanglement: A fundamental quantum phenomenon where two or more qubits become linked, such that the state of one qubit instantly influences the state of the other, no matter how far apart they are.

2. Quantum Teleportation: A process that allows the state of a qubit to be transferred from one location to another using entanglement and classical communication. It involves creating entanglement between qubits and performing measurements to transfer quantum information.

3. Repeater: A device or protocol used to extend quantum communication over long distances by creating entanglement between qubits and facilitating entanglement swapping. The repeater performs entanglement generation and measurement steps, sending classical information to other parties to ensure that the qubits become entangled even if they were initially far apart.

Steps in Entanglement Swapping

1. Initial Entanglement:

   • Setup: Start with two pairs of entangled qubits. For example, we have qubits $A_1$ and $A_2$ in one Bell state and qubits $B_1$ and $B_2$ in another Bell state.
   • Bell State Pairs: These are maximally entangled pairs like $ \left| \Phi^+ \right\rangle = \frac{1}{\sqrt{2}}(\left| 00 \right\rangle + \left| 11 \right\rangle) $.

2. Send Qubits to Repeater:

   • Preparation: Entangle qubits $A_2$ and $B_1$ with each other at a repeater station. This involves creating a new Bell pair between these qubits.

3. Entangle Qubits at Repeater:

   • Entanglement Formation: Create a Bell pair between the repeater's qubits $A_2$ and $B_1$.
   • Measurements: Measure the repeater's qubits $A_2$ and $B_1$. The measurement outcomes are sent to Alice and Bob.

4. Apply Conditional Operations:

   • Alice: Based on the measurement result from the repeater, Alice applies a corrective operation (e.g., a Z gate) to her qubit $A_1$ if needed.
   • Bob: Similarly, Bob applies a corrective operation (e.g., an X gate) to his qubit $B_2$ based on the repeater's measurements.

5. Measurement:

   • Final State: Measure the final states of Alice's and Bob's qubits. The outcomes will show that $A_1$ and $B_2$ are now entangled, even though they were never directly interacted.

Step 2.1: Initialize 4-Qubits

• Define four qubits, which will be used for the entanglement swapping process.

qubits = cirq.NamedQubit.range(4, prefix='q')

Step 2.2: Create Bell Pair

• Create a Bell pair between qubits[0] and qubits[1] (Alice's qubits).
• Create another Bell pair between qubits[2] and qubits[3] (Bob's qubits).

# Define the circuit
circuit = cirq.Circuit()

# Creating Bell Pair between qubits[0] and qubits[1] (Alice's qubits)
circuit.append(cirq.H(qubits[0]))
circuit.append(cirq.CNOT(qubits[0], qubits[1]))

# Creating Bell Pair between qubits[2] and qubits[3] (Bob's qubits)
circuit.append(cirq.H(qubits[2]))
circuit.append(cirq.CNOT(qubits[2], qubits[3]))

# Display the circuit
print(circuit)

q0: ───H───@───
           │
q1: ───────X───

q2: ───H───@───
           │
q3: ───────X───

Step 2.3: Alice and Bob Each Send Half of Their Bell Pair to the Repeater

• $q_0$: Alice's qubit.
• $q_1$: Qubit from Alice's Bell pair sent to the Repeater.
• $q_2$: Qubit from Bob's Bell pair sent to the Repeater.
• $q_3$: Bob's qubit.

In this step, Alice and Bob each send one qubit from their respective Bell pairs to a central repeater.

Step 2.4: Quantum Teleportation

• The qubit from the repeater corresponding to Alice's Bell pair (qubits[1]) is the qubit to be teleported.
• The qubit from the repeater corresponding to Bob's Bell pair (qubits[2]) is half of its entangled pair with Bob.
• Bob's qubit (qubits[3]) is the qubit that will receive the teleported state.

In Practice

• The Repeater:

  • Entangles qubits[1] (Alice's repeater qubit) and qubits[2] (Bob's repeater qubit) to form a standard Bell pair.
  • Measures qubits[1] and qubits[2] and sends the results to Alice and Bob, respectively.

• Alice:

  • Applies a Z gate to qubits[0] (Alice's qubit) only if qubits[1] is in the $|1\rangle$ state.
  • Measures qubits[0].

• Bob:

  • Applies an X gate to qubits[3] (Bob's qubit) only if qubits[2] is in the $|1\rangle$ state.
  • Measures qubits[3].

# Creating a Bell pair between qubits[1] and qubits[2] (the repeater's qubits)
circuit.append(cirq.H(qubits[1]))
circuit.append(cirq.CNOT(qubits[1], qubits[2]))

# Measure qubits[1] and qubits[2]
circuit.append(cirq.measure(qubits[1], qubits[2]))

# Apply Z gate to qubits[0] if qubits[1] is in the |1⟩ state
circuit.append(cirq.CZ(qubits[1], qubits[0]))
circuit.append(cirq.measure(qubits[0]))

# Apply X gate to qubits[3] if qubits[2] is in the |1⟩ state
circuit.append(cirq.CX(qubits[2], qubits[3]))
circuit.append(cirq.measure(qubits[3]))

# Display the circuit
print(circuit)

q0: ───H───@───────────────@───M───
           │               │
q1: ───────X───H───@───M───@───────
                   │   │
q2: ───H───@───────X───M───@───────
           │               │
q3: ───────X───────────────X───M───

Step 2.5: Simulate the result 1000 times

# Run the simulation
sim = cirq.Simulator()
results = sim.run(circuit, repetitions=1000)

# Plot the histogram of the measurement results
hist = cirq.plot_state_histogram(results, plt.subplot(), title='Entanglement Swapping', xlabel='States', ylabel='Occurrences', tick_label=binary_labels(4))

plt.show()

Explanation of Results

In the histogram, we observe non-zero counts only for states where the 1st and 4th qubits (i.e., qubits[0] and qubits[3], or q0 and q3) are the same. This indicates that the entanglement swap was successful. Here’s why:

1. Entanglement Swapping Process:

   • The goal of entanglement swapping is to entangle two qubits (q0 and q3) that were not directly entangled before.
   • This is achieved by using a repeater that first entangles q1 and q2 and then performs quantum teleportation, transferring the entanglement from q1 and q2 to q0 and q3.

2. Conditional Operations:

   • The repeater entangles q1 and q2 and measures them, sending the measurement results to Alice and Bob.
   • Alice applies a Z gate to q0 if q1 is in the $|1\rangle$ state, and Bob applies an X gate to q3 if q2 is in the $|1\rangle$ state.

3. Measurement and Results:

   • After applying the appropriate gates based on the measurement results from the repeater, q0 and q3 become entangled.
   • The histogram reflects the measurement outcomes of q0 and q3. Since entanglement swapping ensures that q0 and q3 are correlated, the only states with non-zero counts in the histogram are those where q0 and q3 have the same value (either both are 0 or both are 1).

4. Conclusion:

   • The non-zero counts in the histogram for states where q0 and q3 are the same confirm that the entanglement swap was successful.
   • If q0 and q3 had different values, this would indicate a failure in the entanglement swapping process.

This result demonstrates that the entanglement swap worked correctly, successfully entangling the qubits q0 and q3 through the repeater and the subsequent quantum teleportation process.

2.6 Variational Algorithm(Minimize Cost)

import random
import matplotlib.pyplot as plt
import numpy as np
from math import radians, degrees
from scipy.optimize import minimize
import cirq
from cirq_web import bloch_sphere

def binary_labels(num_qubits):
    return [bin(x)[2:].zfill(num_qubits) for x in range (2**num_qubits)]

plt.rcParams.update({'font.size': 8})

Part 1: Rotation Gates

1.1: Creating a circuit that applies a 180 degree rotation around the X-axis to a single qubit and visualize in Bloch Sphere

• The cirq.rx gate represents a rotation around the X-axis of the Bloch sphere. The rotation angle is given in radians.

• radians(180) converts 180 degrees to radians, which equals $\pi$ radians. This corresponds to a 180-degree rotation around the X-axis.

• The .on(qubit) method applies this rotation to the qubit q0.

• The cirq.final_state_vector(circuit) function calculates the qubit's final state vector. bloch_sphere.BlochSphere is a hypothetical function for visualizing this state on the Bloch sphere, possibly a custom tool or placeholder not in Cirq.

qubit = cirq.NamedQubit('q0')
circuit = cirq.Circuit()

circuit.append(cirq.rx(radians(180)).on(qubit))

bloch_sphere.BlochSphere(state_vector=cirq.final_state_vector(circuit))

1.2: Creating a circuit that applies a 45 degree rotation around the X-axis to a single qubit and visualize in Bloch Sphere

qubit = cirq.NamedQubit('q0')
circuit = cirq.Circuit()

circuit.append(cirq.rx(radians(45)).on(qubit))

bloch_sphere.BlochSphere(state_vector=cirq.final_state_vector(circuit))

1.3: Creating a circuit that appliesan H-Gate then a 90 degree rotation around the X-axis to a single qubit and visualize.

qubit = cirq.NamedQubit('q0')
circuit = cirq.Circuit()

circuit.append(cirq.H(qubit))
circuit.append(cirq.rz(radians(90)).on(qubit))

bloch_sphere.BlochSphere(state_vector=cirq.final_state_vector(circuit))

1.4: Creating a circuit that applies a 400 degree rotation around the X-axis to a single qubit and visualize in Bloch Sphere

qubit = cirq.NamedQubit('q0')
circuit = cirq.Circuit()

circuit.append(cirq.rx(radians(400)).on(qubit))

bloch_sphere.BlochSphere(state_vector=cirq.final_state_vector(circuit))

Part 2: Implementing Variational Algorithm

Part 2.1: The Cost Function and Expectation Value

Before implementing the full variational algorithm, it is crucial to understand how to define a cost function and compute its expectation value based on the measurements from the quantum circuit.

A cost function is a mathematical function that quantifies the error or deviation of a solution from the desired outcome. In the context of variational algorithms, the cost function is an observable whose expectation value is minimized or maximized to solve a specific problem. The parameters of the quantum circuit are adjusted to optimize this cost function.

Implementing the Cost Function in 4 Steps:

1. Create a Circuit Ansatz:

   • An ansatz is a parameterized quantum circuit that prepares a trial wave function or state. The circuit is designed to be flexible, allowing parameters to be adjusted to minimize or optimize the cost function.
   • Typically, the ansatz consists of a series of quantum gates with variable parameters. These parameters are adjusted during the optimization process.
   • The choice of ansatz can significantly impact the performance of the variational algorithm, as it determines the expressiveness and complexity of the states that can be represented.

2. Simulate the Circuit and Unpack the Result:

   • Once the ansatz is constructed, it is simulated to obtain the quantum state after applying all the gates.
   • The simulation can be done using a quantum simulator or a real quantum device. The output of this simulation is usually a set of measurement results or a state vector.
   • If using a simulator, you can directly obtain the final state vector. On a real device, repeated measurements will provide the probabilities of different outcomes.

3. Calculate the Average (Expected) State:

   • The average or expected state is determined from the measurement results. This involves computing the probabilities or expectation values of observables related to the quantum state.
   • The expectation value is calculated using the formula: $$ \langle O \rangle = \sum_i p_i \langle \psi_i | O | \psi_i \rangle $$ where $p_i$ is the probability of the $i$-th state, and $O$ is the observable.

4. Calculate the Average (Expected) Cost:

   • The cost function is defined based on the problem you are trying to solve. It is usually an observable whose expectation value you wish to minimize or maximize.
   • The average cost is calculated as the expectation value of the cost function using the results from the previous step.
   • The calculated cost guides the optimization process, where the parameters of the ansatz are adjusted to minimize the cost function.

By following these steps, you can implement a cost function for a variational algorithm and compute its expectation value, which is crucial for optimizing the algorithm's parameters.

Step 2.1.1 : Create a circuit anstaz.

• Starting with a simple circuit : Preparing $|1\rangle$ state

Note : To make the measurement result easier, we should name the collection of measurement using the key parameter.

• Specifically, srtting key = result

qubit = cirq.NamedQubit('q0')
circuit = cirq.Circuit()

circuit.append(cirq.X(qubit))
circuit.append(cirq.measure(qubit, key='result'))

circuit

q0: ───X───M('result')───

Step 2.1.2: Simulate the Circuit and Unpack the Result

• Accessing the specific states measured using the key (result) we assigned above.

sim = cirq.Simulator()

results = sim.run(circuit, repetitions=100)

measurements = results.measurements['result']

Step 2.1.3: Calculate the Average (Expected) State

• np.mean(measurements, axis=0) computes the average of measurement outcomes along each column of the measurements array. This provides the average result for each observable or qubit across all experiments. Here, axis=0 specifies that the mean is calculated down each column.

average_state = np.mean(measurements, axis=0)
average_state    

array([1.])

Step 2.1.4 : Define a Cost Function and Calculate the Average (Expected) Cost

• For Example: $Average Cost = Average State * 2$

Note : Here we can define any cost function we want, Like:

• $Average Cost = Average State * 10$
• $Average Cost = 1 - Average State$

....etc

average_cost = average_state[0]*2

average_cost

2.0

Question: Implement the 4-step and find cost where:

• Initial state is $|+\rangle$
• circuit that rotates the qubit around X-axis by 45 degree
• $Average Cost = 1 - Average State$

# Solve

# Creating a circuit anstaz
qubit = cirq.NamedQubit('q0')
circuit = cirq.Circuit()

circuit.append(cirq.H(qubit))
circuit.append(cirq.rx(radians(45)).on(qubit))
circuit.append(cirq.measure(qubit, key='result'))

print('Circuit :',circuit)

# Simulating the Circuit and Unpack the Result
sim = cirq.Simulator()
results = sim.run(circuit, repetitions=100)
measurements = results.measurements['result']


# Calculateing the Average (Expected) State
average_state = np.mean(measurements, axis=0)
print('\nAverage State :',average_state)

 
# Defining a Cost Function and Calculating the Average (Expected) Cost
average_cost = 1 - average_state[0]
print('\nAverage Cost :', average_cost)

Circuit : q0: ───H───Rx(0.25π)───M('result')───

Average State : [0.57]

Average Cost : 0.43000000000000005

Part 2.2: The Full Algorithm

Let's put everything together to implement the full variational algorithm.

Let's Optimize Using SciPy's minimize(...) Function in 3 Steps

1. Define the Average Cost Function Ansatz:

   • The cost function ansatz is a parameterized function that represents the cost associated with a given quantum state.
   • It involves constructing a quantum circuit with adjustable parameters and defining an observable to measure.
   • The expectation value of this observable, calculated from the circuit's output state, forms the cost that needs to be minimized.

2. Define an Initial Guess State:

   • An initial guess for the parameter values of the ansatz is needed to start the optimization process.
   • This initial guess can be randomly generated or based on some prior knowledge of the problem.
   • The choice of the initial guess can affect the convergence and performance of the optimization algorithm.

3. Provide the Average Cost Function Ansatz and Initial Guess to the minimize(...) Function:

   • Use SciPy's minimize function to find the parameter values that minimize the cost function.
   • The minimize function takes the cost function ansatz, initial parameter guess, and optimization method as input arguments.
   • It iteratively adjusts the parameters to find the minimum cost, effectively optimizing the quantum circuit to approximate the desired solution.

By following these steps, we can implement the full variational algorithm to optimize the quantum circuit parameters, aiming to minimize the defined cost function and solve a given problem efficiently.

Step 2.2.1: Define the Average Cost Function Ansatz

• By using previous code creating average_cost function.
• It create circuit that rotates a single qubit around the X-axis by the given angle
• Finally it returns the cost

def average_cost(angle):

    # Creating a circuit anstaz
    qubit = cirq.NamedQubit('q0')
    circuit = cirq.Circuit()

    circuit.append(cirq.rx(radians(angle)).on(qubit))
    circuit.append(cirq.measure(qubit, key='result'))

    # Simulating the Circuit and Unpack the Result
    sim = cirq.Simulator()
    results = sim.run(circuit, repetitions=2000)
    measurements = results.measurements['result']


    # Calculateing the Average (Expected) State
    average_state = np.mean(measurements, axis=0)

    
    # Defining a Cost Function and Calculating the Average (Expected) Cost
    average_cost = 1 - average_state[0]
    
    print('Attempt: ', angle, ' Produces Average Cost: ', average_cost)
    
    return average_cost

Step 2.2.2: Define an Initial Guess State

• Here we are picking the initial angle (in degrees) that the minimize() function will then optimize.
• Picking the best initial guess is a mix of art and science. let's pick 90 degrees since that will produce an equal superposition of $|0\rangle$ and $|1\rangle$

initial_guess = 90

Step 2.2.3: Provide the Average Cost Function Ansatz and Initial Guess to the minimize(...) Function

Note : A trademark of variational and optimization algorithms is that we may get different results each time.

• For Example: Here we may need to run the code to get close to the correct answer (A cost function of 0 at 180 degrees in this case)

Two Important Function:

• minimize(average_cost, initial_guess, method='Powell'):

  • This function call is part of the SciPy library's optimization module. It is used to find the minimum of the scalar function average_cost.
  • average_cost: The function to be minimized. It takes a parameter (the angle) and returns a scalar value representing the cost for that angle.
  • initial_guess: The starting point for the optimization algorithm. This is an initial estimate of the angle that might minimize the cost function. It is provided as a list or array.
  • method='Powell': Specifies the optimization algorithm to be used. Powell's method is a derivative-free optimization algorithm, which is useful for functions that are not smooth or do not have derivatives.

• print('\nOptimized Angle(s) in Degrees: ', [a % 360 for a in result.x]):

  • This line outputs the optimized angles to the console.
  • result.x: After the minimize function is executed, result contains the optimization result, with result.x holding the optimal values of the parameters (the angle(s)).
  • [a % 360 for a in result.x]: This list comprehension converts each optimized angle in result.x to a value between 0 and 360 degrees. The modulo operation % 360 ensures that the angle falls within the typical range for angles in degrees.
  • The print statement outputs a message showing the optimized angle(s) in degrees. The \n at the beginning of the string is a newline character, which moves the output to a new line for better readability.

result = minimize(average_cost, initial_guess, method='Powell')

# Output the optimized parameter 
print('\nOptimized Angle(For which Average Cost = 0) in Degrees: ', [a%360 for a in result.x])

# Output the state on a Bloch Sphere 
qubit = cirq.NamedQubit('q0')
circuit = cirq.Circuit()

circuit.append(cirq.rx(radians(result.x[0])).on(qubit))

bloch_sphere.BlochSphere(state_vector=cirq.final_state_vector(circuit))

Attempt:  [90.]  Produces Average Cost:  0.481
Attempt:  [90.]  Produces Average Cost:  0.5085
Attempt:  [91.]  Produces Average Cost:  0.49150000000000005
Attempt:  [92.618034]  Produces Average Cost:  0.474
Attempt:  [94.09829087]  Produces Average Cost:  0.4595
Attempt:  [96.4933968]  Produces Average Cost:  0.43700000000000006
Attempt:  [140.63973249]  Produces Average Cost:  0.12350000000000005
Attempt:  [212.0700046]  Produces Average Cost:  0.07750000000000001
Attempt:  [182.11799243]  Produces Average Cost:  0.0004999999999999449
Attempt:  [166.27470739]  Produces Average Cost:  0.015000000000000013
Attempt:  [193.55864271]  Produces Average Cost:  0.014000000000000012
Attempt:  [180.15531381]  Produces Average Cost:  0.0
Attempt:  [179.25376067]  Produces Average Cost:  0.0
Attempt:  [178.36122306]  Produces Average Cost:  0.0
Attempt:  [173.74458502]  Produces Average Cost:  0.0034999999999999476
Attempt:  [176.5978243]  Produces Average Cost:  0.0004999999999999449
Attempt:  [266.72244613]  Produces Average Cost:  0.49050000000000005
Attempt:  [178.36122306]  Produces Average Cost:  0.0014999999999999458
Attempt:  [179.36122306]  Produces Average Cost:  0.0
Attempt:  [180.97925706]  Produces Average Cost:  0.0
Attempt:  [179.97925704]  Produces Average Cost:  0.0
Attempt:  [180.36122305]  Produces Average Cost:  0.0
Attempt:  [180.59729103]  Produces Average Cost:  0.0
Attempt:  [180.74318907]  Produces Average Cost:  0.0
Attempt:  [180.83335902]  Produces Average Cost:  0.0
Attempt:  [180.88908711]  Produces Average Cost:  0.0
Attempt:  [180.92352897]  Produces Average Cost:  0.0004999999999999449
Attempt:  [180.86380847]  Produces Average Cost:  0.0

Optimized Angle(For which Average Cost = 0) in Degrees:  [180.86380846974856]

Implementation of the Full Variational Algorithm

This code snippet demonstrates the implementation of a variational algorithm using a simple quantum circuit with a single qubit. The goal is to optimize the rotation angle to minimize a defined cost function.

Function Definition: $average\_cost(angle)$

1. Create a Circuit Ansatz:

   • We define a single-qubit circuit using Cirq.
   • The circuit applies a rotation around the X-axis ($rx$) by an angle (in radians) to the qubit $q0$.
   • The qubit is then measured, with results stored under the key $'result'$.

2. Simulate the Circuit and Unpack the Result:

   • We use Cirq's $Simulator$ to run the circuit for 100 repetitions.
   • The measurement outcomes are stored in the $measurements$ array.

3. Calculate the Average (Expected) State:

   • The average state is calculated as the mean of the measurement outcomes.
   • This average represents the probability of measuring the qubit in the $|1\rangle$ state.

4. Define the Cost Function and Calculate the Average (Expected) Cost:

   • The cost function is defined as $1 - average\_state[0]$, aiming to maximize the probability of measuring the qubit in the $|0\rangle$ state.
   • This value is returned as the cost for a given angle.

Optimization Process

• We define an initial guess for the angle as $90$ degrees.
• SciPy's $minimize$ function is used to optimize the angle, minimizing the $average\_cost$ function.
• The $Powell$ method is chosen for optimization.

Output

• The optimized angle(s) are printed, ensuring they are within a range of $0$ to $360$ degrees.
• A final circuit is constructed with the optimized angle, and its state is visualized on a Bloch Sphere using a hypothetical $bloch\_sphere.BlochSphere$ function.
• Here, we may need to run the code multiple times to get close to the correct answer (a cost function of 0 at 180 degrees in this case). This repetition ensures convergence to the optimal solution due to the stochastic nature of quantum measurements.

Question 1: Implement the Full Variational Algorithm :

• Use an Ansatz circuit with a rotational Z-Gate.
• Define the Cost Function as $(\text{State} - 0.5)^2$.

# 1. Defining the Average Cost Function Ansatz
def average_cost(angle):

    # Creating a circuit anstaz
    qubit = cirq.NamedQubit('q0')
    circuit = cirq.Circuit()

    circuit.append(cirq.rz(radians(angle)).on(qubit))                       # change here!!!
    circuit.append(cirq.measure(qubit, key='result'))

    # Simulating the Circuit and Unpack the Result
    sim = cirq.Simulator()
    results = sim.run(circuit, repetitions=2000)
    measurements = results.measurements['result']


    # Calculateing the Average (Expected) State
    average_state = np.mean(measurements, axis=0)

    
    # Defining a Cost Function and Calculating the Average (Expected) Cost
    average_cost = (average_state[0] - 0.5)**2                              # change here!!!
    
    print('Attempt: ', angle, ' Produces Average Cost: ', average_cost)
    
    return average_cost




# 2. Defining an Initial Guess State
initial_guess = 90                                            # changed here!!! (not necessary 90 is a good guess for here)





# 3. Providing the Average Cost Function Ansatz and Initial Guess to the `minimize(...)` Function
result = minimize(average_cost, initial_guess, method='Powell')

# Output the optimized parameter 
print('\nOptimized Angle(For which Average Cost = 0) in Degrees: ', [a%360 for a in result.x])

# Output the state on a Bloch Sphere 
qubit = cirq.NamedQubit('q0')
circuit = cirq.Circuit()

circuit.append(cirq.rx(radians(result.x[0])).on(qubit))

bloch_sphere.BlochSphere(state_vector=cirq.final_state_vector(circuit))

Attempt:  [90.]  Produces Average Cost:  0.25
Attempt:  [90.]  Produces Average Cost:  0.25
Attempt:  [91.]  Produces Average Cost:  0.25
Attempt:  [92.618034]  Produces Average Cost:  0.25
Attempt:  [91.61803397]  Produces Average Cost:  0.25
Attempt:  [91.99999998]  Produces Average Cost:  0.25
Attempt:  [92.23606797]  Produces Average Cost:  0.25
Attempt:  [92.381966]  Produces Average Cost:  0.25
Attempt:  [92.47213595]  Produces Average Cost:  0.25
Attempt:  [92.52786405]  Produces Average Cost:  0.25
Attempt:  [92.5623059]  Produces Average Cost:  0.25
Attempt:  [92.58792896]  Produces Average Cost:  0.25

Optimized Angle(For which Average Cost = 0) in Degrees:  [92.58792896154584]

Question 2: Implement the Full Variational Algorithm :

• Use an Ansatz circuit with a rotational Y-Gate.
• Define the Cost Function as $(\text{State} - 0.75)^2$.

Note : In this case we are looking for an angle that is a 75% rotation around the Y-axis, meaning the ideal parameter value(angle) is close to either 135 or 225 degrees

# 1. Defining the Average Cost Function Ansatz
def average_cost(angle):

    # Creating a circuit anstaz
    qubit = cirq.NamedQubit('q0')
    circuit = cirq.Circuit()

    circuit.append(cirq.ry(radians(angle)).on(qubit))                       # change here!!!
    circuit.append(cirq.measure(qubit, key='result'))

    # Simulating the Circuit and Unpack the Result
    sim = cirq.Simulator()
    results = sim.run(circuit, repetitions=2000)
    measurements = results.measurements['result']


    # Calculateing the Average (Expected) State
    average_state = np.mean(measurements, axis=0)

    
    # Defining a Cost Function and Calculating the Average (Expected) Cost
    average_cost = (average_state[0] - 0.75)**2                              # change here!!!
    
    print('Attempt: ', angle, ' Produces Average Cost: ', average_cost)
    
    return average_cost




# 2. Defining an Initial Guess State
initial_guess = 0                                            # changed here!!! (choose any)





# 3. Providing the Average Cost Function Ansatz and Initial Guess to the `minimize(...)` Function
result = minimize(average_cost, initial_guess, method='Powell')

# Output the optimized parameter 
print('\nOptimized Angle(For which Average Cost = 0) in Degrees: ', [a%360 for a in result.x])

# Output the state on a Bloch Sphere 
qubit = cirq.NamedQubit('q0')
circuit = cirq.Circuit()

circuit.append(cirq.rx(radians(result.x[0])).on(qubit))

bloch_sphere.BlochSphere(state_vector=cirq.final_state_vector(circuit))

Attempt:  [0.]  Produces Average Cost:  0.5625
Attempt:  [0.]  Produces Average Cost:  0.5625
Attempt:  [1.]  Produces Average Cost:  0.5625
Attempt:  [2.618034]  Produces Average Cost:  0.5625
Attempt:  [1.61803397]  Produces Average Cost:  0.561001
Attempt:  [1.99999998]  Produces Average Cost:  0.5625
Attempt:  [1.49999999]  Produces Average Cost:  0.5625
Attempt:  [1.74999999]  Produces Average Cost:  0.5625
Attempt:  [1.63421431]  Produces Average Cost:  0.5625
Attempt:  [1.57294901]  Produces Average Cost:  0.5617502500000001
Attempt:  [1.60185364]  Produces Average Cost:  0.5625
Attempt:  [3.23606795]  Produces Average Cost:  0.559504
Attempt:  [1.61803397]  Produces Average Cost:  0.5625
Attempt:  [3.23606795]  Produces Average Cost:  0.5625
Attempt:  [5.85410193]  Produces Average Cost:  0.558009
Attempt:  [10.09016993]  Produces Average Cost:  0.5527922500000001
Attempt:  [16.69382261]  Produces Average Cost:  0.537289
Attempt:  [27.37875716]  Produces Average Cost:  0.48163599999999995
Attempt:  [44.66734455]  Produces Average Cost:  0.36844899999999997
Attempt:  [72.64086676]  Produces Average Cost:  0.13950225
Attempt:  [117.90297679]  Produces Average Cost:  0.00012100000000000022
Attempt:  [117.36048971]  Produces Average Cost:  0.0014062499999999984
Attempt:  [191.13860973]  Produces Average Cost:  0.055932250000000024
Attempt:  [145.87649856]  Produces Average Cost:  0.022801000000000005
Attempt:  [100.61438967]  Produces Average Cost:  0.02295224999999999
Attempt:  [123.2809261]  Produces Average Cost:  0.0005522499999999984
Attempt:  [119.35190177]  Produces Average Cost:  4.0000000000000074e-06
Attempt:  [120.52924045]  Produces Average Cost:  3.600000000000006e-05
Attempt:  [119.35190177]  Produces Average Cost:  1.2249999999999634e-05
Attempt:  [237.08576957]  Produces Average Cost:  0.0005062499999999985
Attempt:  [-71.14549928]  Produces Average Cost:  0.16605625
Attempt:  [46.58837148]  Produces Average Cost:  0.36180225000000005
Attempt:  [164.32223632]  Produces Average Cost:  0.053592250000000015
Attempt:  [130.45779517]  Produces Average Cost:  0.005112250000000001
Attempt:  [114.28595557]  Produces Average Cost:  0.002450249999999999
Attempt:  [120.95662297]  Produces Average Cost:  3.600000000000006e-05
Attempt:  [120.05475037]  Produces Average Cost:  2.2499999999998374e-06
Attempt:  [119.92434929]  Produces Average Cost:  2.5000000000000045e-05
Attempt:  [120.39923504]  Produces Average Cost:  6.2499999999997335e-06
Attempt:  [119.99167034]  Produces Average Cost:  0.00010000000000000018
Attempt:  [120.06177886]  Produces Average Cost:  9.000000000000015e-06
Attempt:  [120.03065594]  Produces Average Cost:  6.2499999999997335e-06
Attempt:  [120.04554712]  Produces Average Cost:  1.600000000000003e-05
Attempt:  [238.49146676]  Produces Average Cost:  0.0007022499999999983
Attempt:  [120.05475037]  Produces Average Cost:  9.000000000000015e-06
Attempt:  [237.78861817]  Produces Average Cost:  0.0002402499999999987
Attempt:  [-70.44265068]  Produces Average Cost:  0.174724
Attempt:  [47.29122008]  Produces Average Cost:  0.346921
Attempt:  [165.02508492]  Produces Average Cost:  0.05198399999999999
Attempt:  [131.05396853]  Produces Average Cost:  0.0064802500000000025
Attempt:  [107.94279275]  Produces Average Cost:  0.010920250000000008
Attempt:  [120.98911071]  Produces Average Cost:  7.224999999999918e-05
Attempt:  [119.86762139]  Produces Average Cost:  2.2499999999998374e-06
Attempt:  [115.31274229]  Produces Average Cost:  0.0029160000000000054
Attempt:  [119.32154144]  Produces Average Cost:  0.0001690000000000003
Attempt:  [119.65903741]  Produces Average Cost:  0.0001690000000000003
Attempt:  [119.7879494]  Produces Average Cost:  4.9000000000000087e-05
Attempt:  [119.95346023]  Produces Average Cost:  3.600000000000006e-05
Attempt:  [119.9004089]  Produces Average Cost:  9.02499999999991e-05
Attempt:  [119.8371894]  Produces Average Cost:  0.0002250000000000004
Attempt:  [119.8801451]  Produces Average Cost:  1.600000000000003e-05
Attempt:  [119.8559974]  Produces Average Cost:  0.0
Attempt:  [119.84881338]  Produces Average Cost:  4.224999999999935e-05
Attempt:  [119.86043737]  Produces Average Cost:  0.0
Attempt:  [119.8623805]  Produces Average Cost:  0.00010000000000000018
Attempt:  [119.85849424]  Produces Average Cost:  0.0002722499999999987
Attempt:  [119.66612437]  Produces Average Cost:  0.00011024999999999903
Attempt:  [119.86043737]  Produces Average Cost:  2.2499999999998374e-06
Attempt:  [237.59430517]  Produces Average Cost:  4.9000000000000087e-05
Attempt:  [-70.63696368]  Produces Average Cost:  0.18062499999999998
Attempt:  [47.09690708]  Produces Average Cost:  0.35105625
Attempt:  [164.83077192]  Produces Average Cost:  0.052440999999999995
Attempt:  [130.8872348]  Produces Average Cost:  0.004692250000000001
Attempt:  [115.62886015]  Produces Average Cost:  0.001156000000000002
Attempt:  [120.72484436]  Produces Average Cost:  0.0002402499999999987
Attempt:  [119.01241232]  Produces Average Cost:  2.0249999999999537e-05
Attempt:  [119.49770727]  Produces Average Cost:  0.0001562499999999989
Attempt:  [120.19061145]  Produces Average Cost:  0.00010000000000000018
Attempt:  [119.72188681]  Produces Average Cost:  5.624999999999927e-05
Attempt:  [119.98655264]  Produces Average Cost:  5.624999999999927e-05
Attempt:  [119.80751576]  Produces Average Cost:  0.00032400000000000056
Attempt:  [119.90860911]  Produces Average Cost:  0.0003062499999999986
Attempt:  [119.84022311]  Produces Average Cost:  2.0249999999999537e-05
Attempt:  [119.87883734]  Produces Average Cost:  2.5000000000000045e-05
Attempt:  [119.85271621]  Produces Average Cost:  6.2499999999997335e-06
Attempt:  [119.86526647]  Produces Average Cost:  4.224999999999935e-05
Attempt:  [119.85748815]  Produces Average Cost:  2.0249999999999537e-05
Attempt:  [119.86228192]  Produces Average Cost:  0.00013224999999999896
Attempt:  [119.85931087]  Produces Average Cost:  2.5000000000000045e-05
Attempt:  [119.86114192]  Produces Average Cost:  0.00010000000000000018
Attempt:  [119.86000708]  Produces Average Cost:  0.0002890000000000005
Attempt:  [119.86070648]  Produces Average Cost:  5.624999999999927e-05
Attempt:  [119.86027301]  Produces Average Cost:  4.9000000000000087e-05
Attempt:  [119.86054016]  Produces Average Cost:  6.2499999999997335e-06
Attempt:  [119.86037459]  Produces Average Cost:  1.0000000000000019e-06
Attempt:  [119.86031923]  Produces Average Cost:  7.224999999999918e-05
Attempt:  [119.86039857]  Produces Average Cost:  4.0000000000000074e-06
Attempt:  [119.86035344]  Produces Average Cost:  9.02499999999991e-05
Attempt:  [119.86038375]  Produces Average Cost:  2.2499999999998374e-06
Attempt:  [119.86036651]  Produces Average Cost:  4.224999999999935e-05
Attempt:  [119.86037809]  Produces Average Cost:  4.224999999999935e-05
Attempt:  [119.86037151]  Produces Average Cost:  0.00012100000000000022
Attempt:  [119.86037593]  Produces Average Cost:  2.0249999999999537e-05
Attempt:  [119.86037341]  Produces Average Cost:  1.600000000000003e-05
Attempt:  [119.86037522]  Produces Average Cost:  2.0249999999999537e-05

Optimized Angle(For which Average Cost = 0) in Degrees:  [119.86037459051762]

2.7 Grovers Algorithm

Grover's Algorithm

Grover's Algorithm is a quantum search algorithm that efficiently finds a specific item in an unsorted database. It offers a quadratic speedup over classical search algorithms, making it one of the most important quantum algorithms.

Key Concepts

1. Quantum Superposition: Quantum bits (qubits) can exist in a superposition of states, allowing a quantum computer to process multiple possibilities simultaneously.

2. Amplitude Amplification: Grover's algorithm uses a process called amplitude amplification to increase the probability of measuring the correct solution.

3. Oracle: The oracle is a quantum subroutine that marks the correct solution by flipping the sign of the amplitude of the target state.

4. Grover Iteration: The core of the algorithm is the Grover iteration, which consists of two main steps: the oracle application and the diffusion operator (inversion about the mean).

Steps of Grover's Algorithm

1. Initialization:

   • Start with $n$ qubits initialized to the state $|0\rangle$. Apply the Hadamard gate to create an equal superposition of all possible states.

2. Oracle Application:

   • Use the oracle to identify the target state by flipping its amplitude.

3. Diffusion Operator:

   • Apply the diffusion operator, which reflects all amplitudes about their average, effectively amplifying the amplitude of the marked state.

4. Repetition:

   • Repeat the Grover iteration (oracle + diffusion) approximately $\frac{\pi}{4} \sqrt{N}$ times, where $N$ is the total number of possible solutions.

5. Measurement:

   • Measure the quantum state. The correct solution will have the highest probability of being observed.

Efficiency and Applications

• Efficiency: Grover's algorithm reduces the number of search operations from $O(N)$ to $O(\sqrt{N})$, providing a significant speedup for large databases.

• Applications: The algorithm can be applied to various problems, such as solving unstructured search problems, database search, and cryptanalysis.

Grover's algorithm is a powerful example of how quantum computing can outperform classical methods for specific tasks. Its ability to efficiently search through large datasets demonstrates the potential of quantum algorithms to revolutionize fields requiring complex search operations.

import cirq
import numpy as np
import math
import scipy
import random

import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings("ignore")

def binary_labels(num_qubits):
    return [bin(x)[2:].zfill(num_qubits) for x in range (2**num_qubits)]

plt.rcParams.update({'font.size': 8})

Part 1: Defining the Size of the Problem

Step 1.1: Initialize Problem Parameters

• num_of_choices = 8: The number of possible choices or items to search through.
• correct_choice = 2: The index of the correct choice/item we are searching for.
• n = int(math.log(num_of_choices, 2)): The number of qubits required to represent all choices in binary form. It uses the logarithm base 2 of the number of choices because each qubit doubles the number of representable states.
• num_qubits = 3: The number of qubits needed to represent the choices in a quantum circuit. This is because $2^3 = 8$, which allows us to represent 8 different states.

num_of_choices = 8
correct_choice = 2

n = int(math.log(num_of_choices, 2))
num_qubits = n

num_qubits

3

Step 1.2: Define Function generate_binary_strings(num_of_choices)

• This function generates all binary strings of a certain length based on the number of choices.
• A for loop iterates over the range of numbers from 0 to $2^n - 1$.
• binary_string = bin(i)[2:].zfill(n): For each number i, its binary representation is calculated using bin(i). The [2:] slice removes the '0b' prefix, and zfill(n) ensures that the binary string is n digits long, padding with zeros if necessary.
• Each binary string is appended to the binary_strings list.

def generate_binary_strings(num_of_choices):
    n = int(math.log(num_of_choices, 2))
    binary_strings = []
    for i in range(2**n):
        binary_string = bin(i)[2:].zfill(n)
        binary_strings.append(binary_string)
    return binary_strings

Step 1.3: Generate and Display Binary Strings

• binary_strings = generate_binary_strings(num_of_choices): Call the function to generate binary strings for the given number of choices.
• binary_strings: Output the generated list of binary strings, representing all possible states in the quantum search space.

binary_strings = generate_binary_strings(num_of_choices)
binary_strings

['000', '001', '010', '011', '100', '101', '110', '111']

Part 2: Setting up the Grover Problem

Step 2.1: Creating the Oracle and Using It to Create the Search Problem

• Function make_oracle: Implements the oracle function:

  • $f(x) = 1$ if $x$ matches the marked bitstring ($x = x'$).
  • $f(x) = 0$ otherwise.

• Operation:

  • Negate the qubits corresponding to 0 bits in the marked bitstring to prepare for the oracle operation.
  • Apply the Toffoli gate (or a generalized multi-controlled X gate) to flip the ancilla qubit, marking the correct solution.
  • Negate the qubits again to restore their original state.

def make_oracle(qubits, ancilla, marked_bitstring):
    for (q, bit) in zip(qubits, marked_bitstring):
        if not bit:
            yield cirq.X(q)
    
    controls = len(qubits)
    mcx_gate = cirq.ControlledGate(sub_gate=cirq.X, num_controls=controls)
    yield mcx_gate(*qubits, ancilla)
    
    for (q, bit) in zip(qubits, marked_bitstring):
        if not bit:
            yield cirq.X(q)

Step 2.2: Grover Iteration

• Function grover_iteration: Performs one round of the Grover Iteration.
  • Creates a quantum circuit to perform Grover's search algorithm.
  • Initializes qubits in an equal superposition and prepares the ancilla qubit.
  • Executes the oracle function and constructs the Grover operator.
  • Measures the qubits to obtain the result.

def grover_iteration(qubits, ancilla, marked_bitstring, reps=1):
    circuit = cirq.Circuit()
    circuit.append(cirq.H.on_each(*qubits))
    circuit.append([cirq.X(ancilla), cirq.H(ancilla)])
    
    for r in range(reps):
        for (q, bit) in zip(qubits, marked_bitstring):
            if not bit:
                circuit.append(cirq.X(q))
        
        controls = len(qubits)
        mcx_gate = cirq.ControlledGate(sub_gate=cirq.X, num_controls=controls)
        circuit.append(mcx_gate(*qubits, ancilla))
        
        for (q, bit) in zip(qubits, marked_bitstring):
            if not bit:
                circuit.append(cirq.X(q))
        
        circuit.append(cirq.H.on_each(*qubits))
        circuit.append(cirq.X.on_each(*qubits))
        
        controls = len(qubits)
        mcx_gate = cirq.ControlledGate(sub_gate=cirq.X, num_controls=controls)
        circuit.append(mcx_gate(*qubits, ancilla))
        
        circuit.append(cirq.X.on_each(*qubits))
        circuit.append(cirq.H.on_each(*qubits))
    
    circuit.append(cirq.measure(*qubits, key="result"))
    return circuit

Step 2.3: Initialize Two Qubit Registers

• Qubits: Create a register of qubits for the main quantum operations.
• Ancilla: An additional qubit used in the oracle function for marking the correct solution.

qubits = cirq.LineQubit.range(num_qubits)
ancilla = cirq.NamedQubit('Ancilla')

Step 2.4: Get Marked Bitstring

• Function get_marked_bitstring: Converts the correct choice into a binary string with a specified length.
  • Converts the correct choice to its binary representation.
  • Pads the binary string to match the number of qubits.

def get_marked_bitstring(correct_choice, num_qubits):
    binary_representation = list(bin(correct_choice)[2:])
    marked_bitstring = [eval(i) for i in binary_representation]
    desired_length = num_qubits
    marked_bitstring = [0] * (desired_length - len(marked_bitstring)) + marked_bitstring
    return marked_bitstring

marked_bitstring = get_marked_bitstring(correct_choice, num_qubits)
print(marked_bitstring)

[0, 1, 0]

Step 2.5: Creating the Grover Circuit Using the Function

• Oracle: Generates the oracle circuit to mark the correct bitstring.
• Grover Circuit: Constructs the entire Grover search circuit and performs the specified number of iterations.

oracle = make_oracle(qubits, ancilla, marked_bitstring)
circuit = grover_iteration(qubits=qubits, ancilla=ancilla, marked_bitstring=marked_bitstring, reps=2)
print(circuit)

0: ─────────H───X───@───X───H───X───@───X───H───X───@───X───H───X───@───X───H───M('result')───
                    │               │               │               │           │
1: ─────────H───────@───H───X───────@───X───H───────@───H───X───────@───X───H───M─────────────
                    │               │               │               │           │
2: ─────────H───X───@───X───H───X───@───X───H───X───@───X───H───X───@───X───H───M─────────────
                    │               │               │               │
Ancilla: ───X───H───X───────────────X───────────────X───────────────X─────────────────────────

Part 3: Visualizing the Result of Grover's Algorithm

Step 3.1: Define Helper Functions

• Function bitstring: Converts a list of bits into a string.
• Function binary_labels: Generates binary labels for all possible states given the number of qubits.

def bitstring(bits):
    return "".join(str(int(b)) for b in bits)

def binary_labels(num_qubits):
    return [bin(x)[2:].zfill(num_qubits) for x in range(2**num_qubits)]

Step 3.2: Run the Circuit Using a Simulator

• Simulator: Use Cirq's simulator to run the circuit and obtain results.
• Repetitions: Perform multiple repetitions to gather statistics on the measurement outcomes.

simulator = cirq.Simulator()
result = simulator.run(circuit, repetitions=1024)

Step 3.3: Analyze the Results

• Histogram: Compute the frequencies of each measurement outcome.
• Most Common Bitstring: Identify the most frequently observed bitstring.
• Match Check: Verify if the most common bitstring matches the marked bitstring.

frequencies = result.histogram(key='result', fold_func=bitstring)
print('Sample results: \n{}'.format(frequencies))

most_common_bit_string = frequencies.most_common(1)[0][0]
print('\nMost common bitstring: {}'.format(most_common_bit_string))
print('\nFound match? {}'.format(most_common_bit_string == bitstring(marked_bitstring)))

Sample results: 
Counter({'010': 961, '000': 14, '011': 11, '001': 10, '101': 8, '111': 8, '100': 7, '110': 5})

Most common bitstring: 010

Found match? True

Step 3.4: Plot the Histogram

• Histogram Plot: Visualize the measurement outcomes using a histogram.
• Labels: Use binary labels for the x-axis to represent quantum states.

hist = cirq.plot_state_histogram(result, plt.subplot(), title='Grover\'s Algorithm', xlabel='States', ylabel='Occurrences', tick_label=binary_labels(3))
plt.show()

Discussing the Results

1. Sample Results:

   • The output shows a distribution of different bitstrings obtained from the measurements.
   • The bitstring '010' has the highest frequency, indicating it is the most probable outcome.

2. Most Common Bitstring:

   • The most common bitstring '010' matches the marked bitstring, which is the correct choice to be found by Grover's algorithm.
   • The fact that this result matches the marked bitstring consistently across different runs indicates that Grover's algorithm successfully amplifies the probability of measuring the correct solution.

3. Correct Search:

   • Grover's algorithm uses amplitude amplification to increase the likelihood of measuring the correct bitstring.
   • In classical search, you would need to check each option one by one, requiring $O(N)$ operations for $N$ possible solutions.
   • Grover's algorithm, on the other hand, finds the correct solution in approximately $O(\sqrt{N})$ operations, making it significantly more efficient.

Iteration Count and Efficiency

1. Number of Iterations (Reps):

   • The number of repetitions, reps, in the Grover iteration is crucial for determining the success of the algorithm.
   • The optimal number of iterations is approximately $\frac{\pi}{4} \sqrt{N}$, where $N$ is the number of possible solutions. For your case, with 8 choices, the optimal number is about 2 iterations, which is what you have set.

2. Efficiency:

   • The efficiency of Grover's algorithm comes from its ability to dramatically reduce the number of operations needed to find the correct solution compared to classical search methods.
   • As the number of possible solutions increases, the advantage of Grover's algorithm becomes more pronounced. For example, for a problem with $N = 10,000$ possible solutions, Grover's algorithm would need around 100 iterations instead of checking all 10,000 solutions classically.

3. Probability Amplification:

   • With each iteration, the probability of measuring the correct solution increases. This amplification ensures that, after the optimal number of iterations, the correct solution has the highest probability.

Conclusion

Grover's algorithm is a powerful quantum search algorithm that efficiently finds the marked solution with high probability using significantly fewer iterations than classical search methods. Your implementation, which correctly identifies the marked bitstring as the most common result, showcases this efficiency. As the problem size increases, Grover's algorithm's advantage becomes even more substantial, highlighting its importance in quantum computing.

Compiled by Joydeb Gan Prokas